As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Construindo e usando definições de tipo em documentos do esquema de recursos
<a name="type-definitions"></a>

Todos os elementos nos esquemas se resolvem em definições de tipo. Essas definições de tipo são definições de *tipo primitivo (como booleanos, cadeias de caracteres, números) ou definições* de tipo com *namespace (definições de tipo criadas a partir de definições* de tipo primitivas por conveniência).

Ao definir um esquema personalizado, você pode usar definições primitivas e definições de tipo de namespace.

**Contents**
+ [Definições de tipo primitivo](#primitive-type-definitions)
  + [booleanos](#boolean-types)
  + [Suporte ao tipo inteiro](#integers-support)
  + [Números](#numbers)
  + [Strings](#strings)
  + [Nulos](#nulls)
  + [Matrizes](#arrays)
  + [Objetos](#objects)
+ [Definições de tipo com namespace](#namespaced-type-definitions)
  + [tipos de `matéria`](#matter-types)
  + [tipos de `leis`](#aws-types)
    + [Definição do tipo de bitmap](#bitmap-type-definition)
    + [Definição do tipo Enum](#enum-type-definition)

## Definições de tipo primitivo
<a name="primitive-type-definitions"></a>

As definições de tipo primitivo são os alicerces de todas as definições de tipo definidas em integrações gerenciadas. Todas as definições de namespace, incluindo definições de tipo personalizadas, se transformam em uma definição de tipo primitiva por meio da `$ref` palavra-chave ou da palavra-chave. `type`

Todos os tipos primitivos são anuláveis usando a `nullable` palavra-chave, e você pode identificar todos os tipos primitivos usando a palavra-chave. `type`

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

Os tipos booleanos oferecem suporte a valores padrão.

Definição da amostra:

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

### Suporte ao tipo inteiro
<a name="integers-support"></a>



Os tipos inteiros oferecem suporte ao seguinte:
+ Valores de `default`
+ Valores de `maximum`
+ Valores de `minimum`
+ Valores de `exclusiveMaximum`
+ Valores de `exclusiveMinimum`
+ Valores de `multipleOf`

Se o valor `x` estiver sendo validado, o seguinte deve ser verdadeiro:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

**nota**  
Números com uma parte fracionária zero são considerados inteiros, mas números de ponto flutuante são rejeitados.  

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

Embora você possa especificar ambos `minimum` `exclusiveMinimum` e/ou ambos `maximum``exclusiveMaximum`, não recomendamos usar os dois simultaneamente.

Definições de amostra:

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

Definição alternativa:

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

### Números
<a name="numbers"></a>

Use o tipo de número para qualquer tipo numérico, incluindo números inteiros e números de ponto flutuante.

Os tipos de números oferecem suporte ao seguinte:
+ Valores de `default`
+ Valores de `maximum`
+ Valores de `minimum`
+ Valores de `exclusiveMaximum`
+ Valores de `exclusiveMinimum`
+ `multipleOf`valores. O múltiplo pode ser um número de ponto flutuante.

Se o valor `x` estiver sendo validado, o seguinte deve ser verdadeiro:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

Embora você possa especificar ambos `minimum` `exclusiveMinimum` e/ou ambos `maximum``exclusiveMaximum`, não recomendamos usar os dois simultaneamente.

Definições de amostra:

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

Definição alternativa:

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

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

Os tipos de string oferecem suporte ao seguinte:
+ Valores de `default`
+ restrições de comprimento (devem ser números não negativos), incluindo valores `maxLength` `minLength`
+ `pattern`valores para expressões regulares

Quando você define expressões regulares, a string é válida se a expressão corresponder a qualquer lugar dentro da string. Por exemplo, a expressão regular `p` corresponde a qualquer string contendo um p, como “apple”, não apenas à string “p”. Para maior clareza, recomendamos usar expressões regulares com `^...$` (por exemplo,`^p$`), a menos que você tenha um motivo específico para não fazer isso.

Definição da amostra:

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

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

Os tipos nulos aceitam apenas um único valor:`null`.

Definição da amostra:

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

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

Os tipos de matriz oferecem suporte ao seguinte:
+ `default`— uma lista que será usada como valor padrão.
+ `items`— Definição do tipo JSON imposta a todos os elementos da matriz.
+ Restrições de comprimento (deve ser um número não negativo)
  + `minItems`
  + `maxItems`
+ `pattern`valores para Regex
+ `uniqueItems`— um booleano indicando se os elementos na matriz precisam ser exclusivos
+ `prefixItems`— uma matriz em que cada item é um esquema que corresponde a cada índice da matriz do documento. Ou seja, uma matriz em que o primeiro elemento valida o primeiro elemento da matriz de entrada, o segundo elemento valida o segundo elemento da matriz de entrada e assim por diante.

Definição da amostra:

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

Exemplos de validação de matriz:

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

Definição alternativa usando validação de tupla:

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

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

Os tipos de objeto oferecem suporte ao seguinte:
+ Restrições de propriedade
  + `properties`— Defina as propriedades (pares de valores-chave) de um objeto usando a `properties` palavra-chave. O valor de `properties` é um objeto, em que cada chave é o nome de uma propriedade e cada valor é um esquema usado para validar essa propriedade. Qualquer propriedade que não corresponda a nenhum dos nomes de propriedade na `properties` palavra-chave é ignorada por essa palavra-chave.
  + `required`— Por padrão, as propriedades definidas pela `properties` palavra-chave não são obrigatórias. No entanto, você pode fornecer uma lista das propriedades necessárias usando a `required` palavra-chave. A `required` palavra-chave usa uma matriz de zero ou mais strings. Cada uma dessas sequências de caracteres deve ser exclusiva.
  + `propertyNames`— Essa palavra-chave permite o controle sobre o RegEx padrão dos nomes das propriedades. Por exemplo, talvez você queira impor que todas as propriedades de um objeto tenham nomes seguindo uma convenção específica.
  + `patternProperties`— Isso mapeia expressões regulares para esquemas. Se o nome de uma propriedade corresponder à expressão regular fornecida, o valor da propriedade deverá ser validado em relação ao esquema correspondente. Por exemplo, use `patternProperties` para especificar que um valor deve corresponder a um esquema específico, dado um tipo específico de nome de propriedade. 
  + `additionalProperties`— Essa palavra-chave controla como as propriedades extras são tratadas. Propriedades extras são propriedades cujos nomes não estão listados na palavra-chave properties ou que correspondem a qualquer uma das expressões regulares em`patternProperties`. Por padrão, propriedades adicionais são permitidas. Definir esse campo como `false` significa que nenhuma propriedade adicional é permitida.
  + `unevaluatedProperties`— Essa palavra-chave é semelhante`additionalProperties`, exceto pelo fato de poder reconhecer propriedades declaradas em subesquemas. `unevaluatedProperties`funciona coletando todas as propriedades que são validadas com êxito ao processar os esquemas e usá-las como a lista de propriedades permitidas. Isso permite que você faça coisas mais complexas, como adicionar propriedades condicionalmente. Consulte o exemplo abaixo para obter mais detalhes.
+ `anyOf`— O valor dessa palavra-chave DEVE ser uma matriz não vazia. Cada item da matriz DEVE ser um esquema JSON válido. Uma instância é validada com sucesso em relação a essa palavra-chave se for validada com êxito *em pelo menos* um esquema definido pelo valor dessa palavra-chave.
+ `oneOf`— O valor dessa palavra-chave DEVE ser uma matriz não vazia. Cada item da matriz DEVE ser um esquema JSON válido. Uma instância é validada com sucesso em relação a essa palavra-chave se for validada com base em *exatamente* um esquema definido pelo valor dessa palavra-chave.

Exemplo de obrigatório:

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

// Schema Compliant
{
  "test": 4
}

// NOT Schema Compliant
{}
```

PropertyNames exemplo:

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

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

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

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

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

UnevaluatedProperties exemplo:

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

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

// Schema Compliant
"short"
12

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

OneOf exemplo:

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

## Definições de tipo com namespace
<a name="namespaced-type-definitions"></a>

As definições de tipo com namespace são tipos criados a partir de tipos primitivos. Esses tipos devem seguir o formato que as integrações `{{namespace}}.{{typename}}.` gerenciadas fornecem tipos predefinidos nos namespaces `aws` e. `matter` Você pode usar qualquer namespace para tipos personalizados, exceto os reservados `aws` e `matter` os namespaces.

Para encontrar as definições de tipo com namespace disponíveis, use a [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API com o `Type` filtro definido como. `definition`

### tipos de `matéria`
<a name="matter-types"></a>

Encontre tipos de dados no `matter` namespace usando a [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API com o `Namespace` filtro definido como `matter` e o `Type` filtro definido como. `definition`

### tipos de `leis`
<a name="aws-types"></a>

Encontre tipos de dados no `aws` namespace usando a [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API com o `Namespace` filtro definido como `aws` e o `Type` filtro definido como. `definition`

#### Definição do tipo de bitmap
<a name="bitmap-type-definition"></a>

Os bitmaps têm duas propriedades obrigatórias:
+ `type`deve ser um objeto
+ `properties`deve ser um objeto contendo cada definição de bit. Cada bit é um objeto com propriedades `extrinsicId` `value` e. O valor de cada bit deve ser um número inteiro com um valor mínimo de 0 e um valor máximo de pelo menos 1.

Exemplo de definição de 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
}
```

#### Definição do tipo Enum
<a name="enum-type-definition"></a>

Os enums exigem três propriedades:
+ `type`deve ser um objeto
+ `enum`deve ser uma matriz de cadeias de caracteres exclusivas, com no mínimo um item
+ `extrinsicIdMap`é um objeto com propriedades que são os valores enumerados. O valor de cada uma das propriedades deve ser o identificador extrínseco que corresponde ao valor enum.

Definição de enumeração da amostra:

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