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

# Membangun dan menggunakan definisi tipe dalam dokumen skema kemampuan
<a name="type-definitions"></a>

Semua elemen dalam skema memutuskan untuk mengetik definisi. Definisi tipe ini adalah *definisi tipe primitif* (seperti boolean, string, angka) atau definisi tipe *namespaced (definisi tipe yang dibangun dari definisi tipe* primitif untuk kenyamanan).

Saat Anda mendefinisikan skema khusus, Anda dapat menggunakan definisi primitif dan definisi tipe namespace.

**Contents**
+ [Definisi tipe primitif](#primitive-type-definitions)
  + [Boolean](#boolean-types)
  + [Dukungan tipe integer](#integers-support)
  + [Nomor](#numbers)
  + [String](#strings)
  + [Nulls](#nulls)
  + [Array](#arrays)
  + [Objek](#objects)
+ [Definisi tipe namespaced](#namespaced-type-definitions)
  + [jenis `materi`](#matter-types)
  + [jenis `aws`](#aws-types)
    + [Definisi jenis bitmap](#bitmap-type-definition)
    + [Definisi tipe enum](#enum-type-definition)

## Definisi tipe primitif
<a name="primitive-type-definitions"></a>

Definisi tipe primitif adalah blok bangunan untuk semua definisi tipe yang didefinisikan dalam integrasi terkelola. Semua definisi namespace, termasuk definisi tipe kustom, diselesaikan ke definisi tipe primitif baik melalui `$ref` kata kunci atau kata kunci. `type`

Semua tipe primitif dapat dibatalkan dengan menggunakan `nullable` kata kunci, dan Anda dapat mengidentifikasi semua tipe primitif dengan menggunakan kata kunci. `type`

### Boolean
<a name="boolean-types"></a>

Jenis Boolean mendukung nilai default.

Definisi sampel:

```
{
    "type" : "boolean",
    "default" : "false",
    "nullable" : true
}
```

### Dukungan tipe integer
<a name="integers-support"></a>



Jenis integer mendukung hal berikut:
+ Nilai `default`
+ Nilai `maximum`
+ Nilai `minimum`
+ Nilai `exclusiveMaximum`
+ Nilai `exclusiveMinimum`
+ Nilai `multipleOf`

Jika nilai yang `x` divalidasi, berikut ini harus benar:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

**catatan**  
Angka dengan bagian pecahan nol dianggap bilangan bulat, tetapi angka floating point ditolak.  

```
1.0 // Schema-Compliant
3.1415926 // NOT Schema-Compliant
```

Meskipun Anda dapat menentukan keduanya `minimum` dan `exclusiveMinimum` atau keduanya `maximum` dan`exclusiveMaximum`, kami tidak menyarankan untuk menggunakan keduanya secara bersamaan.

Contoh definisi:

```
{
    "type" : "integer",
    "default" : 2,
    "nullable" : true,
    "maximum" : 10,
    "minimum" : 0,
    "multipleOf": 2
}
```

Definisi alternatif:

```
{
    "type" : "integer",
    "default" : 2,
    "nullable" : true,
    "exclusiveMaximum" : 11,
    "exclusiveMinimum" : -1,
    "multipleOf": 2
}
```

### Nomor
<a name="numbers"></a>

Gunakan jenis angka untuk jenis numerik apa pun, termasuk bilangan bulat dan angka floating point.

Jenis nomor mendukung hal berikut:
+ Nilai `default`
+ Nilai `maximum`
+ Nilai `minimum`
+ Nilai `exclusiveMaximum`
+ Nilai `exclusiveMinimum`
+ `multipleOf`nilai. Kelipatannya bisa menjadi nomor floating point.

Jika nilai yang `x` divalidasi, berikut ini harus benar:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

Meskipun Anda dapat menentukan keduanya `minimum` dan `exclusiveMinimum` atau keduanya `maximum` dan`exclusiveMaximum`, kami tidak menyarankan untuk menggunakan keduanya secara bersamaan.

Contoh definisi:

```
{
    "type" : "number",
    "default" : 0.4,
    "nullable" : true,
    "maximum" : 10.2,
    "minimum" : 0.2,
    "multipleOf": 0.2
}
```

Definisi alternatif:

```
{
    "type" : "number",
    "default" : 0.4,
    "nullable" : true,
    "exclusiveMaximum" : 10.2,
    "exclusiveMinimum" : 0.2,
    "multipleOf": 0.2
}
```

### String
<a name="strings"></a>

Jenis string mendukung hal berikut:
+ Nilai `default`
+ kendala panjang (harus angka non-negatif) termasuk dan nilai `maxLength` `minLength`
+ `pattern`nilai untuk ekspresi reguler

Saat Anda mendefinisikan ekspresi reguler, string valid jika ekspresi cocok di mana saja di dalam string. Misalnya, ekspresi reguler `p` cocok dengan string apa pun yang mengandung p, seperti “apple”, bukan hanya string “p”. Untuk kejelasan, kami sarankan mengelilingi ekspresi reguler dengan `^...$` (misalnya,`^p$`), kecuali Anda memiliki alasan khusus untuk tidak melakukannya.

Definisi sampel:

```
{
    "type" : "string",
    "default" : "defaultString",
    "nullable" : true,
    "maxLength": 10,
    "minLength": 1,
    "pattern" : "^([0-9a-fA-F]{2})+$"
}
```

### Nulls
<a name="nulls"></a>

Tipe nol hanya menerima satu nilai:`null`.

Definisi sampel:

```
{ "type": "null" }
```

### Array
<a name="arrays"></a>

Jenis array mendukung hal berikut:
+ `default`— daftar yang akan digunakan sebagai nilai default.
+ `items`— Definisi tipe JSON dikenakan pada semua elemen array.
+ Kendala panjang (harus berupa angka non-negatif)
  + `minItems`
  + `maxItems`
+ `pattern`nilai untuk Regex
+ `uniqueItems`— boolean yang menunjukkan jika elemen dalam array harus unik
+ `prefixItems`— sebuah array di mana setiap item adalah skema yang sesuai dengan setiap indeks dari array dokumen. Artinya, array di mana elemen pertama memvalidasi elemen pertama dari array input, elemen kedua memvalidasi elemen kedua dari array input, dan seterusnya.

Definisi sampel:

```
{
   "type": "array",
   "default": ["1", "2"],
   "items" : {
        "type": "string",
        "pattern": "^([a-zA-Z0-9_ -/]+)$"
    },
    "minItems" : 1,
    "maxItems": 4,
    "uniqueItems" : true,
}
```

Contoh validasi array:

```
//Examples:
["1", "2", "3", "4"] // Schema-Compliant
[]                   // NOT Schema-Compliant: minItems=1
["1", "1"]           // NOT Schema-Compliant: uniqueItems=true
["{"]                // NOT Schema-Compliant: Does not match the RegEx pattern.
```

Definisi alternatif menggunakan validasi Tuple:

```
{
    "type": "array",
    "prefixItems": [
        { "type": "number" },
        { "type": "string" },
        { "enum": ["Street", "Avenue", "Boulevard"] },
        { "enum": ["NW", "NE", "SW", "SE"] }
    ]
}
          
//Examples:
[1600, "Pennsylvania", "Avenue", "NW"]               // Schema-Compliant

// And, by default, it's also okay to add additional items to end:
[1600, "Pennsylvania", "Avenue", "NW", "Washington"] // Schema-Compliant
```

### Objek
<a name="objects"></a>

Jenis objek mendukung hal berikut:
+ Kendala properti
  + `properties`— Tentukan properti (pasangan kunci-nilai) dari suatu objek dengan menggunakan kata kunci. `properties` Nilai `properties` adalah objek, di mana setiap kunci adalah nama properti dan setiap nilai adalah skema yang digunakan untuk memvalidasi properti itu. Properti apa pun yang tidak cocok dengan nama properti dalam `properties` kata kunci diabaikan oleh kata kunci ini.
  + `required`— Secara default, properti yang ditentukan oleh `properties` kata kunci tidak diperlukan. Namun, Anda dapat memberikan daftar properti yang diperlukan menggunakan `required` kata kunci. `required`Kata kunci mengambil array nol atau lebih string. Masing-masing string ini harus unik.
  + `propertyNames`— Kata kunci ini memungkinkan kontrol atas RegEx pola untuk nama properti. Misalnya, Anda mungkin ingin menegakkan bahwa semua properti objek memiliki nama mengikuti konvensi tertentu.
  + `patternProperties`— Ini memetakan ekspresi reguler ke skema. Jika nama properti cocok dengan ekspresi reguler yang diberikan, nilai properti harus memvalidasi terhadap skema yang sesuai. Misalnya, gunakan `patternProperties` untuk menentukan bahwa nilai harus cocok dengan skema tertentu, mengingat jenis nama properti tertentu. 
  + `additionalProperties`Kata kunci ini mengontrol bagaimana properti tambahan ditangani. Properti tambahan adalah properti yang namanya tidak tercantum dalam kata kunci properti atau yang cocok dengan ekspresi reguler mana pun`patternProperties`. Secara default, properti tambahan diperbolehkan. Menyetel bidang ini `false` berarti tidak ada properti tambahan yang diizinkan.
  + `unevaluatedProperties`— Kata kunci ini mirip dengan `additionalProperties` kecuali bahwa ia dapat mengenali properti yang dideklarasikan dalam subskema. `unevaluatedProperties`bekerja dengan mengumpulkan properti apa pun yang berhasil divalidasi saat memproses skema dan menggunakannya sebagai daftar properti yang diizinkan. Ini memungkinkan Anda melakukan hal-hal yang lebih kompleks seperti menambahkan properti secara kondisional. Lihat contoh di bawah ini untuk lebih jelasnya.
+ `anyOf`— Nilai kata kunci ini HARUS berupa array yang tidak kosong. Setiap item dari array HARUS menjadi Skema JSON yang valid. Sebuah instance berhasil memvalidasi terhadap kata kunci ini jika berhasil memvalidasi terhadap *setidaknya* satu skema yang ditentukan oleh nilai kata kunci ini.
+ `oneOf`— Nilai kata kunci ini HARUS berupa array yang tidak kosong. Setiap item dari array HARUS menjadi Skema JSON yang valid. Sebuah instance berhasil memvalidasi terhadap kata kunci ini jika berhasil memvalidasi dengan *tepat* satu skema yang ditentukan oleh nilai kata kunci ini.

Contoh yang diperlukan:

```
{
  "type": "object",
  "required": ["test"]
}

// Schema Compliant
{
  "test": 4
}

// NOT Schema Compliant
{}
```

PropertyNames contoh:

```
{
  "type": "object",
  "propertyNames": {
    "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
  }
}

// Schema Compliant
{
  "_a_valid_property_name_001": "value"
}

// NOT Schema Compliant
{
  "001 invalid": "value"
}
```

PatternProperties contoh:

```
{
  "type": "object",
  "patternProperties": {
    "^S_": { "type": "string" },
    "^I_": { "type": "integer" }
  }
}

// Schema Compliant
{ "S_25": "This is a string" }
{ "I_0": 42 }

// NOT Schema Compliant
{ "S_0": 42 } // Value must be a string
{ "I_42": "This is a string" } // Value must be an integer
```

AdditionalProperties contoh:

```
{
  "type": "object",
  "properties": {
    "test": {
        "type": "string"
    }
  },
  "additionalProperties": false
}

// Schema Compliant
{
  "test": "value"
}
OR
{}

// NOT Schema Compliant
{
    "notAllowed": false
}
```

UnevaluatedProperties contoh:

```
{
  "type": "object",
  "properties": {
    "standard_field": { "type": "string" }
  },
  "patternProperties": {
    "^@": { "type": "integer" } // Allows properties starting with '@'
  },
  "unevaluatedProperties": false // No other properties allowed
}

// Schema Compliant
{
  "standard_field": "some value",
  "@id": 123,
  "@timestamp": 1678886400
}
// This passes because "standard_field" is evaluated by properties, 
// "@id" and "@timestamp" are evaluated by patternProperties, 
// and no other properties remain unevaluated.

// NOT Schema Compliant
{
  "standard_field": "some value",
  "another_field": "unallowed"
}
// This fails because "another_field" is unevaluated and doesn't match 
// the @ pattern, leading to a violation of unevaluatedProperties: false
```

AnyOf contoh:

```
{
  "anyOf": [
    { "type": "string", "maxLength": 5 },
    { "type": "number", "minimum": 0 }
  ]
}

// Schema Compliant
"short"
12

// NOT Schema Compliant
"too long"
-5
```

OneOf contoh:

```
{
  "oneOf": [
    { "type": "number", "multipleOf": 5 },
    { "type": "number", "multipleOf": 3 }
  ]
}

// Schema Compliant
10
9

// NOT Schema compliant
2  // Not a multiple of either 5 or 3
15 // Multiple of both 5 and 3 is rejected.
```

## Definisi tipe namespaced
<a name="namespaced-type-definitions"></a>

Definisi tipe namespaced adalah tipe yang dibangun dari tipe primitif. Tipe ini harus mengikuti format Integrasi `{{namespace}}.{{typename}}.` Terkelola yang menyediakan tipe yang telah ditentukan di bawah `aws` dan `matter` ruang nama. Anda dapat menggunakan namespace apa pun untuk jenis kustom kecuali ruang nama yang dicadangkan `aws` dan`matter`.

Untuk menemukan definisi tipe namespace yang tersedia, gunakan [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API dengan `Type` filter disetel ke. `definition`

### jenis `materi`
<a name="matter-types"></a>

Temukan tipe data di bawah `matter` namespace menggunakan [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API dengan `Namespace` filter disetel ke `matter` dan filter disetel ke`Type`. `definition`

### jenis `aws`
<a name="aws-types"></a>

Temukan tipe data di bawah `aws` namespace menggunakan [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API dengan `Namespace` filter disetel ke `aws` dan filter disetel ke`Type`. `definition`

#### Definisi jenis bitmap
<a name="bitmap-type-definition"></a>

Bitmap memiliki dua properti yang diperlukan:
+ `type`harus menjadi objek
+ `properties`harus berupa objek yang berisi setiap definisi bit. Setiap bit adalah objek dengan properti `extrinsicId` dan`value`. Nilai setiap bit harus berupa bilangan bulat dengan nilai minimum 0 dan nilai maksimum minimal 1.

Contoh definisi bitmap:

```
{
    "title" : "Sample Bitmap Type",
    "description" : "Type definition for SampleBitmap.",
    "$ref" : "/schema-versions/definition/aws.bitmap@1.0 ",
    "type" : "object",
    "additionalProperties" : false,
    "properties" : {
        "Bit1" : {
            "extrinsicId" : "0x0000",
            "value" : {
                "type" : "integer",
                "maximum" : 1,
                "minimum" : 0
            }
        },
        "Bit2" : {
            "extrinsicId" : "0x0001",
            "value" : {
                "type" : "integer",
                "maximum" : 1,
                "minimum" : 0
            }
        }
    }
}
   
// Schema Compliant
{
    "Bit1": 1,
    "Bit1": 0
}

// NOT Schema Compliant
{
    "Bit1": -1,
    "Bit1": 0
}
```

#### Definisi tipe enum
<a name="enum-type-definition"></a>

Enum membutuhkan tiga properti:
+ `type`harus menjadi objek
+ `enum`harus berupa array string unik, dengan minimal satu item
+ `extrinsicIdMap`adalah objek dengan properti yang merupakan nilai enum. Nilai masing-masing properti harus menjadi pengidentifikasi ekstrinsik yang sesuai dengan nilai enum.

Contoh definisi enum:

```
{
    "title" : "SampleEnum Type",
    "description" : "Type definition for SampleEnum.",
    "$ref" : "/schema-versions/definition/aws.enum@1.0",
    "type" : "string",
    "enum" : [
        "EnumValue0",
        "EnumValue1",
        "EnumValue2"
    ],
    "extrinsicIdMap" : {
        "EnumValue0" : "0",
        "EnumValue1" : "1",
        "EnumValue2" : "2"
    }
}
              
// Schema Compliant
"EnumValue0"
"EnumValue1"
"EnumValue2"

// NOT Schema Compliant
"NotAnEnumValue"
```