Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Creazione e utilizzo delle definizioni dei tipi nei documenti dello schema delle capacità
<a name="type-definitions"></a>

Tutti gli elementi degli schemi si risolvono in definizioni di tipo. Queste definizioni di tipo sono definizioni di *tipo primitive (come booleani, stringhe, numeri) o definizioni* di tipo con *namespace (definizioni di tipo basate su definizioni di tipo* primitive per comodità).

Quando si definisce uno schema personalizzato, è possibile utilizzare sia definizioni primitive che definizioni di tipi di namespace.

**Contents**
+ [Definizioni di tipi primitivi](#primitive-type-definitions)
  + [Booleani](#boolean-types)
  + [Supporto per tipi di numeri interi](#integers-support)
  + [Numeri](#numbers)
  + [Stringhe](#strings)
  + [Nulls](#nulls)
  + [Matrici](#arrays)
  + [Oggetti](#objects)
+ [definizioni dei tipi con namespace](#namespaced-type-definitions)
  + [`tipi di argomenti`](#matter-types)
  + [`tipi di aws`](#aws-types)
    + [Definizione del tipo di bitmap](#bitmap-type-definition)
    + [Definizione del tipo Enum](#enum-type-definition)

## Definizioni di tipi primitivi
<a name="primitive-type-definitions"></a>

Le definizioni di tipo primitive sono gli elementi costitutivi di tutte le definizioni di tipo definite nelle integrazioni gestite. Tutte le definizioni dello spazio dei nomi, incluse le definizioni dei tipi personalizzate, si risolvono in una definizione di tipo primitiva tramite la parola chiave o la `$ref` parola chiave. `type`

Tutti i tipi primitivi sono annullabili utilizzando la `nullable` parola chiave ed è possibile identificare tutti i tipi primitivi utilizzando la parola chiave. `type`

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

I tipi booleani supportano i valori predefiniti.

Definizione di esempio:

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

### Supporto per tipi di numeri interi
<a name="integers-support"></a>



I tipi interi supportano quanto segue:
+ `default` valori
+ `maximum` valori
+ `minimum` valori
+ `exclusiveMaximum` valori
+ `exclusiveMinimum` valori
+ `multipleOf` valori

Se `x` è il valore da convalidare, deve essere vero quanto segue:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

**Nota**  
I numeri con una parte frazionaria zero sono considerati numeri interi, ma i numeri in virgola mobile vengono rifiutati.  

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

Sebbene sia possibile specificare entrambi `minimum` e `exclusiveMinimum` o entrambi `maximum` e`exclusiveMaximum`, non è consigliabile utilizzarli entrambi contemporaneamente.

Definizioni di esempio:

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

Definizione alternativa:

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

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

Utilizza il tipo numerico per qualsiasi tipo numerico, inclusi numeri interi e numeri in virgola mobile.

I tipi di numeri supportano quanto segue:
+ `default` valori
+ `maximum` valori
+ `minimum` valori
+ `exclusiveMaximum` valori
+ `exclusiveMinimum` valori
+ `multipleOf`valori. Il multiplo può essere un numero in virgola mobile.

Se `x` è il valore da convalidare, deve essere vero quanto segue:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

Sebbene sia possibile specificare entrambi `minimum` e `exclusiveMinimum` o entrambi `maximum` e`exclusiveMaximum`, non è consigliabile utilizzarli entrambi contemporaneamente.

Definizioni di esempio:

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

Definizione alternativa:

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

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

I tipi di stringa supportano quanto segue:
+ `default` valori
+ vincoli di lunghezza (devono essere numeri non negativi) inclusi e valori `maxLength` `minLength`
+ `pattern`valori per le espressioni regolari

Quando si definiscono espressioni regolari, la stringa è valida se l'espressione corrisponde a un punto qualsiasi all'interno della stringa. Ad esempio, l'espressione regolare `p` corrisponde a qualsiasi stringa contenente una p, come «apple», non solo alla stringa «p». Per motivi di chiarezza, consigliamo di racchiudere le espressioni regolari con `^...$` (ad esempio,`^p$`), a meno che non abbiate un motivo specifico per non farlo.

Definizione di esempio:

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

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

I tipi nulli accettano solo un singolo valore:`null`.

Definizione di esempio:

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

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

I tipi di array supportano quanto segue:
+ `default`— un elenco che verrà utilizzato come valore predefinito.
+ `items`— Definizione del tipo JSON imposta a tutti gli elementi dell'array.
+ Vincoli di lunghezza (deve essere un numero non negativo)
  + `minItems`
  + `maxItems`
+ `pattern`valori per Regex
+ `uniqueItems`— un booleano che indica se gli elementi dell'array devono essere unici
+ `prefixItems`— un array in cui ogni elemento è uno schema che corrisponde a ciascun indice dell'array del documento. Cioè, un array in cui il primo elemento convalida il primo elemento dell'array di input, il secondo elemento convalida il secondo elemento dell'array di input e così via.

Definizione di esempio:

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

Esempi di convalida degli 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.
```

Definizione alternativa che utilizza la convalida delle 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
```

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

I tipi di oggetti supportano quanto segue:
+ Vincoli di proprietà
  + `properties`— Definire le proprietà (coppie chiave-valore) di un oggetto utilizzando la parola chiave. `properties` Il valore di `properties` è un oggetto, dove ogni chiave è il nome di una proprietà e ogni valore è uno schema utilizzato per convalidare quella proprietà. Qualsiasi proprietà che non corrisponde a nessuno dei nomi di proprietà nella `properties` parola chiave viene ignorata da questa parola chiave.
  + `required`— Per impostazione predefinita, le proprietà definite dalla `properties` parola chiave non sono obbligatorie. Tuttavia, è possibile fornire un elenco di proprietà obbligatorie utilizzando la `required` parola chiave. La `required` parola chiave accetta una matrice di zero o più stringhe. Ognuna di queste stringhe deve essere unica.
  + `propertyNames`— Questa parola chiave consente di controllare lo RegEx schema dei nomi delle proprietà. Ad esempio, potreste voler imporre che tutte le proprietà di un oggetto abbiano nomi che seguano una convenzione specifica.
  + `patternProperties`— Questo associa le espressioni regolari agli schemi. Se il nome di una proprietà corrisponde all'espressione regolare specificata, il valore della proprietà deve essere convalidato rispetto allo schema corrispondente. Ad esempio, utilizzare `patternProperties` per specificare che un valore deve corrispondere a uno schema particolare, dato un particolare tipo di nome di proprietà. 
  + `additionalProperties`— Questa parola chiave controlla come vengono gestite le proprietà aggiuntive. Le proprietà aggiuntive sono proprietà i cui nomi non sono elencati nella parola chiave properties o che corrispondono a `patternProperties` nessuna delle espressioni regolari di. Per impostazione predefinita, sono consentite proprietà aggiuntive. L'impostazione di questo campo su `false` significa che non sono consentite proprietà aggiuntive.
  + `unevaluatedProperties`— Questa parola chiave è simile a, `additionalProperties` tranne per il fatto che può riconoscere le proprietà dichiarate nei sottoschemi. `unevaluatedProperties`funziona raccogliendo tutte le proprietà che vengono convalidate con successo durante l'elaborazione degli schemi e utilizzandole come elenco di proprietà consentite. Ciò consente di eseguire operazioni più complesse come l'aggiunta di proprietà in modo condizionale. Fate riferimento all'esempio seguente per maggiori dettagli.
+ `anyOf`— Il valore di questa parola chiave DEVE essere un array non vuoto. Ogni elemento dell'array DEVE essere uno schema JSON valido. Un'istanza viene convalidata correttamente rispetto a questa parola chiave se viene convalidata con successo *su almeno* uno schema definito dal valore di questa parola chiave.
+ `oneOf`— Il valore di questa parola chiave DEVE essere un array non vuoto. Ogni elemento dell'array DEVE essere uno schema JSON valido. Un'istanza viene convalidata correttamente rispetto a questa parola chiave se viene convalidata con successo *esattamente* su uno schema definito dal valore di questa parola chiave.

Esempio di obbligatorio:

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

// Schema Compliant
{
  "test": 4
}

// NOT Schema Compliant
{}
```

PropertyNames esempio:

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

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

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

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

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

UnevaluatedProperties esempio:

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

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

// Schema Compliant
"short"
12

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

OneOf esempio:

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

## definizioni dei tipi con namespace
<a name="namespaced-type-definitions"></a>

Le definizioni dei tipi con namespace sono tipi creati a partire da tipi primitivi. Questi tipi devono seguire il formato che `{{namespace}}.{{typename}}.` Managed Integrations fornisce tipi predefiniti nei namespace e. `aws` `matter` È possibile utilizzare qualsiasi spazio dei nomi per i tipi personalizzati ad eccezione dei namespace riservati e dei nomi. `aws` `matter`

Per trovare le definizioni dei tipi con namespace disponibili, utilizza l'API con il filtro impostato su. [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)`Type``definition`

### `tipi di argomenti`
<a name="matter-types"></a>

Trova i tipi di dati nel `matter` namespace utilizzando l'[ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API con il `Namespace` filtro impostato su `matter` e il `Type` filtro impostato su. `definition`

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

Trova i tipi di dati nello spazio dei `aws` nomi utilizzando l'[ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API con il `Namespace` filtro impostato su `aws` e il `Type` filtro impostato su. `definition`

#### Definizione del tipo di bitmap
<a name="bitmap-type-definition"></a>

Le bitmap hanno due proprietà obbligatorie:
+ `type`deve essere un oggetto
+ `properties`deve essere un oggetto contenente ogni definizione di bit. Ogni bit è un oggetto con proprietà `extrinsicId` e`value`. Il valore di ogni bit deve essere un numero intero con un valore minimo di 0 e un valore massimo di almeno 1.

Esempio di definizione 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
}
```

#### Definizione del tipo Enum
<a name="enum-type-definition"></a>

Le enumerazioni richiedono tre proprietà:
+ `type`deve essere un oggetto
+ `enum`deve essere un array di stringhe uniche, con almeno un elemento
+ `extrinsicIdMap`è un oggetto con proprietà che sono i valori enum. Il valore di ciascuna proprietà deve essere l'identificatore estrinseco che corrisponde al valore enum.

Esempio di definizione 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"
```