Definizioni di tipi primitivi definizioni dei tipi con namespace

Creazione e utilizzo delle definizioni dei tipi nei documenti dello schema delle capacità

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 create a partire da definizioni di tipo primitive per comodità).

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

Indice

Definizioni di tipi primitivi

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

I tipi booleani supportano i valori predefiniti.

Definizione di esempio:


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

Supporto per tipi di numeri interi

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 eexclusiveMaximum, 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

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
multipleOfvalori. 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 eexclusiveMaximum, 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

I tipi di stringa supportano quanto segue:

default valori
vincoli di lunghezza (devono essere numeri non negativi) inclusi e valori maxLength minLength
patternvalori 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

I tipi nulli accettano solo un singolo valore:null.

Definizione di esempio:


{ "type": "null" }

Matrici

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
patternvalori 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 utilizzando 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

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. unevaluatedPropertiesfunziona 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

Le definizioni dei tipi con namespace sono tipi creati a partire da tipi primitivi. Questi tipi devono seguire il formato Le integrazioni namespace.typename. gestite forniscono tipi predefiniti nei namespace e. aws matter Puoi 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. ListSchemaVersionsTypedefinition

Tipi di `matter`

Trova i tipi di dati nello spazio dei matter nomi utilizzando l'ListSchemaVersionsAPI con il filtro impostato su matter e il Namespace filtro impostato su. Type definition

Tipi di `aws`

Trova i tipi di dati nel aws namespace utilizzando l'ListSchemaVersionsAPI con il filtro impostato su aws e il Namespace Type filtro impostato su. definition

Definizione del tipo di bitmap

Le bitmap hanno due proprietà obbligatorie:

typedeve essere un oggetto
propertiesdeve essere un oggetto contenente ogni definizione di bit. Ogni bit è un oggetto con proprietà extrinsicId evalue. 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

Le enumerazioni richiedono tre proprietà:

typedeve essere un oggetto
enumdeve 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"

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Schema per le definizioni dei tipi

Comandi ed eventi dei dispositivi

Creazione e utilizzo delle definizioni dei tipi nei documenti dello schema delle capacità

Indice

Definizioni di tipi primitivi

Booleani

Supporto per tipi di numeri interi

Nota

Numeri

Stringhe

Nulls

Matrici

Oggetti

definizioni dei tipi con namespace

Tipi di matter

Tipi di aws

Definizione del tipo di bitmap

Definizione del tipo Enum

Tipi di `matter`

Tipi di `aws`