Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Creación y uso de definiciones de tipos en documentos de esquemas de capacidades
<a name="type-definitions"></a>

Todos los elementos de los esquemas se resuelven en definiciones de tipos. Estas definiciones de tipos son definiciones de *tipos primitivas (como booleanos, cadenas o números) o definiciones* de tipos con espacios de *nombres (definiciones de tipos creadas a partir de definiciones* de tipos primitivas para mayor comodidad).

Al definir un esquema personalizado, puede utilizar tanto definiciones primitivas como definiciones de tipos de espacios de nombres.

**Contents**
+ [Definiciones de tipos primitivos](#primitive-type-definitions)
  + [Booleanos](#boolean-types)
  + [Soporte de tipo entero](#integers-support)
  + [Números](#numbers)
  + [Cadenas](#strings)
  + [Nulos](#nulls)
  + [Matrices](#arrays)
  + [Objects](#objects)
+ [Definiciones de tipos de espacios de nombres](#namespaced-type-definitions)
  + [`tipos de materia`](#matter-types)
  + [`tipos de AWS`](#aws-types)
    + [Definición del tipo de mapa de bits](#bitmap-type-definition)
    + [Definición de tipo de enumeración](#enum-type-definition)

## Definiciones de tipos primitivos
<a name="primitive-type-definitions"></a>

Las definiciones de tipos primitivas son los componentes básicos de todas las definiciones de tipos definidas en las integraciones gestionadas. Todas las definiciones de espacios de nombres, incluidas las definiciones de tipos personalizadas, se resuelven en una definición de tipo primitiva mediante la `$ref` palabra clave o la palabra clave. `type`

Todos los tipos primitivos son anulables con la `nullable` palabra clave, y usted puede identificar todos los tipos primitivos con la palabra clave. `type`

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

Los tipos booleanos admiten valores predeterminados.

Ejemplo de definición:

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

### Soporte de tipo entero
<a name="integers-support"></a>



Los tipos enteros admiten lo siguiente:
+ Valores `default`
+ Valores `maximum`
+ Valores `minimum`
+ Valores `exclusiveMaximum`
+ Valores `exclusiveMinimum`
+ Valores `multipleOf`

Si `x` es el valor que se está validando, debe cumplirse lo siguiente:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

**nota**  
Los números con una parte fraccionaria cero se consideran enteros, pero se rechazan los números de coma flotante.  

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

Si bien puede especificar ambos `minimum` `exclusiveMinimum` o ambos `maximum` y`exclusiveMaximum`, no recomendamos usar ambos simultáneamente.

Ejemplos de definiciones:

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

Definición alternativa:

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

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

Utilice el tipo de número para cualquier tipo numérico, incluidos los números enteros y los números de punto flotante.

Los tipos de números admiten lo siguiente:
+ Valores `default`
+ Valores `maximum`
+ Valores `minimum`
+ Valores `exclusiveMaximum`
+ Valores `exclusiveMinimum`
+ `multipleOf`valores. El múltiplo puede ser un número de punto flotante.

Si `x` es el valor que se está validando, debe cumplirse lo siguiente:
+ `x` ≥ `minimum`
+ `x` > `exclusiveMinimum`
+ `x` < `exclusiveMaximum`

Si bien puede especificar ambos `minimum` `exclusiveMinimum` o ambos `maximum` y`exclusiveMaximum`, no recomendamos usar ambos simultáneamente.

Ejemplos de definiciones:

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

Definición alternativa:

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

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

Los tipos de cadenas admiten lo siguiente:
+ Valores `default`
+ restricciones de longitud (deben ser números no negativos), incluidos los valores `maxLength` y `minLength`
+ `pattern`valores para expresiones regulares

Al definir expresiones regulares, la cadena es válida si la expresión coincide con cualquier punto de la cadena. Por ejemplo, la expresión regular `p` coincide con cualquier cadena que contenga una p, como «manzana», no solo con la cadena «p». Para mayor claridad, te recomendamos que coloques las expresiones regulares entre `^...$` (por ejemplo,`^p$`), a menos que tengas un motivo específico para no hacerlo.

Ejemplo de definición:

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

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

Los tipos nulos aceptan solo un valor:`null`.

Ejemplo de definición:

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

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

Los tipos de matrices admiten lo siguiente:
+ `default`— una lista que se utilizará como valor por defecto.
+ `items`— Definición de tipo JSON impuesta a todos los elementos de la matriz.
+ Restricciones de longitud (debe ser un número no negativo)
  + `minItems`
  + `maxItems`
+ `pattern`valores para Regex
+ `uniqueItems`— un booleano que indica si los elementos de la matriz deben ser únicos
+ `prefixItems`— una matriz en la que cada elemento es un esquema que corresponde a cada índice de la matriz del documento. Es decir, una matriz en la que el primer elemento valida el primer elemento de la matriz de entrada, el segundo elemento valida el segundo elemento de la matriz de entrada, etc.

Ejemplo de definición:

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

Ejemplos de validación de matrices:

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

Definición alternativa mediante la validación de tuplas:

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

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

Los tipos de objetos admiten lo siguiente:
+ Restricciones de propiedad
  + `properties`— Defina las propiedades (pares clave-valor) de un objeto mediante la `properties` palabra clave. El valor de `properties` es un objeto, donde cada clave es el nombre de una propiedad y cada valor es un esquema utilizado para validar esa propiedad. Esta `properties` palabra clave ignora cualquier propiedad que no coincida con ninguno de los nombres de propiedad de la palabra clave.
  + `required`— De forma predeterminada, las propiedades definidas por la `properties` palabra clave no son obligatorias. Sin embargo, puede proporcionar una lista de las propiedades obligatorias mediante la `required` palabra clave. La `required` palabra clave toma una matriz de cero o más cadenas. Cada una de estas cadenas debe ser única.
  + `propertyNames`— Esta palabra clave permite controlar el RegEx patrón de los nombres de las propiedades. Por ejemplo, es posible que desee exigir que todas las propiedades de un objeto tengan nombres que sigan una convención específica.
  + `patternProperties`— Esto asigna las expresiones regulares a los esquemas. Si el nombre de una propiedad coincide con la expresión regular dada, el valor de la propiedad debe validarse con el esquema correspondiente. Por ejemplo, se utiliza `patternProperties` para especificar que un valor debe coincidir con un esquema concreto, dado un tipo concreto de nombre de propiedad. 
  + `additionalProperties`— Esta palabra clave controla cómo se gestionan las propiedades adicionales. Las propiedades adicionales son propiedades cuyos nombres no aparecen en la palabra clave properties o que coinciden con alguna de las expresiones regulares que contiene`patternProperties`. De forma predeterminada, se permiten propiedades adicionales. Si se establece este campo en, `false` significa que no se permiten propiedades adicionales.
  + `unevaluatedProperties`— Esta palabra clave es similar, `additionalProperties` excepto en que puede reconocer las propiedades declaradas en los subesquemas. `unevaluatedProperties`funciona recopilando todas las propiedades que se hayan validado correctamente al procesar los esquemas y utilizarlas como lista de propiedades permitidas. Esto le permite hacer cosas más complejas, como añadir propiedades de forma condicional. Consulte el ejemplo siguiente para obtener más información.
+ `anyOf`— El valor de esta palabra clave DEBE ser una matriz no vacía. Cada elemento de la matriz DEBE ser un esquema JSON válido. Una instancia se valida correctamente con esta palabra clave si se valida correctamente con *al menos* un esquema definido por el valor de esta palabra clave.
+ `oneOf`— El valor de esta palabra clave DEBE ser una matriz no vacía. Cada elemento de la matriz DEBE ser un esquema JSON válido. Una instancia se valida correctamente con esta palabra clave si se valida correctamente con *exactamente* un esquema definido por el valor de esta palabra clave.

Ejemplo de obligatorio:

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

// Schema Compliant
{
  "test": 4
}

// NOT Schema Compliant
{}
```

PropertyNames ejemplo:

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

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

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

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

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

UnevaluatedProperties ejemplo:

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

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

// Schema Compliant
"short"
12

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

OneOf ejemplo:

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

## Definiciones de tipos de espacios de nombres
<a name="namespaced-type-definitions"></a>

Las definiciones de tipos de espacios de nombres son tipos creados a partir de tipos primitivos. Estos tipos deben seguir el formato que `{{namespace}}.{{typename}}.` Managed Integrations proporciona tipos predefinidos en los `aws` espacios de nombres y. `matter` Puede usar cualquier espacio de nombres para los tipos personalizados, excepto los espacios de nombres reservados y los espacios de nombres. `aws` `matter`

Para encontrar las definiciones de tipos de espacios de nombres disponibles, usa la [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API con el filtro configurado en. `Type` `definition`

### `tipos de materia`
<a name="matter-types"></a>

Busque los tipos de datos en el espacio de `matter` nombres mediante la [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API con el `Namespace` filtro establecido en `matter` y el `Type` filtro establecido en. `definition`

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

Busque los tipos de datos en el espacio de `aws` nombres mediante la [ListSchemaVersions](https://docs.aws.amazon.com/iot-mi/latest/APIReference/API_ListSchemaVersions.html)API con el `Namespace` filtro establecido en `aws` y el `Type` filtro establecido en. `definition`

#### Definición del tipo de mapa de bits
<a name="bitmap-type-definition"></a>

Los mapas de bits tienen dos propiedades obligatorias:
+ `type`debe ser un objeto
+ `properties`debe ser un objeto que contenga la definición de cada bit. Cada bit es un objeto con propiedades `extrinsicId` y`value`. El valor de cada bit debe ser un número entero con un valor mínimo de 0 y un valor máximo de al menos 1.

Ejemplo de definición de mapa de bits:

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

#### Definición de tipo de enumeración
<a name="enum-type-definition"></a>

Las enumeraciones requieren tres propiedades:
+ `type`debe ser un objeto
+ `enum`debe ser una matriz de cadenas únicas, con un mínimo de un elemento
+ `extrinsicIdMap`es un objeto con propiedades que son los valores de enumeración. El valor de cada una de las propiedades debe ser el identificador extrínseco que corresponde al valor de enumeración.

Ejemplo de definición de enumeración:

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