Definições de tipo primitivo Definições de tipo com namespace

Criação e uso de definições de tipo em documentos do esquema de recursos

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.

Sumário

Definições de tipo primitivo

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

Os tipos booleanos oferecem suporte a valores padrão.

Definição da amostra:


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

Suporte ao tipo inteiro

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

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
multipleOfvalores. 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 maximumexclusiveMaximum, 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

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
patternvalores 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

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

Definição da amostra:


{ "type": "null" }

Matrizes

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
patternvalores 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

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 cadeias de caracteres. 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 empatternProperties. Por padrão, propriedades adicionais são permitidas. Definir esse campo como false significa que nenhuma propriedade adicional é permitida.
- unevaluatedProperties— Essa palavra-chave é semelhanteadditionalProperties, exceto pelo fato de poder reconhecer propriedades declaradas em subesquemas. unevaluatedPropertiesfunciona 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

As definições de tipo com namespace são tipos criados a partir de tipos primitivos. Esses tipos devem seguir o formato. 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 ListSchemaVersionsAPI com o Type filtro definido como. definition

Tipos do `matter`

Encontre tipos de dados no matter namespace usando a ListSchemaVersionsAPI com o Namespace filtro definido como matter e o Type filtro definido como. definition

Tipos do `aws`

Encontre tipos de dados no aws namespace usando a ListSchemaVersionsAPI com o Namespace filtro definido como aws e o Type filtro definido como. definition

Definição do tipo de bitmap

Os bitmaps têm duas propriedades obrigatórias:

typedeve ser um objeto
propertiesdeve 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 de enumeração

Os enums exigem três propriedades:

typedeve ser um objeto
enumdeve 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"

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Esquema para definições de tipo

Comandos e eventos do dispositivo

Criação e uso de definições de tipo em documentos do esquema de recursos

Sumário

Definições de tipo primitivo

booleanos

Suporte ao tipo inteiro

nota

Números

Strings

Nulos

Matrizes

Objetos

Definições de tipo com namespace

Tipos do matter

Tipos do aws

Definição do tipo de bitmap

Definição do tipo de enumeração

Tipos do `matter`

Tipos do `aws`