// staticdata.dev — jsonSchemaKeywords
// Generated file. Do not edit by hand.
// SPDX-License-Identifier: MIT

export const jsonSchemaKeywords = [
  {
    "keyword": "$anchor",
    "appliesTo": [
      "any"
    ],
    "description": "Defines a plain-name fragment anchor within a schema resource. The value must be a valid anchor string. References can target it with a URI fragment like '#anchorName'."
  },
  {
    "keyword": "$comment",
    "appliesTo": [
      "any"
    ],
    "description": "Provides a place for schema authors to include comments. The value must be a string. Validators must not attach any meaning to it; it is purely for human readers."
  },
  {
    "keyword": "$defs",
    "appliesTo": [
      "any"
    ],
    "description": "Defines a set of reusable sub-schemas. The value is an object whose property values are schemas. Sub-schemas defined here do not constrain the instance by themselves; they must be referenced via $ref or similar."
  },
  {
    "keyword": "$dynamicAnchor",
    "appliesTo": [
      "any"
    ],
    "description": "Works like $anchor but marks the location as a dynamic anchor that can be overridden by $dynamicRef when composing schemas. Allows extension points in reusable schema libraries."
  },
  {
    "keyword": "$dynamicRef",
    "appliesTo": [
      "any"
    ],
    "description": "Like $ref, but resolves dynamically by walking the dynamic scope to find the outermost matching $dynamicAnchor. Enables open recursion and extension of recursive schemas."
  },
  {
    "keyword": "$id",
    "appliesTo": [
      "any"
    ],
    "description": "Sets the base URI and identifies the schema resource. Must be an absolute URI or a URI-reference that resolves to an absolute URI. Changes how relative $ref URIs within the schema are resolved."
  },
  {
    "keyword": "$ref",
    "appliesTo": [
      "any"
    ],
    "description": "References another schema by URI. The value must be a string URI. The referenced schema is applied to the instance in place of the $ref keyword. In Draft 2020-12, sibling keywords are allowed alongside $ref."
  },
  {
    "keyword": "$schema",
    "appliesTo": [
      "any"
    ],
    "description": "Declares which dialect of JSON Schema the schema is written in. Must be an absolute URI. Validators use it to determine which keywords and semantics apply. Should be used in the document root schema and may appear in the roots of embedded schema resources, but must not appear elsewhere."
  },
  {
    "keyword": "$vocabulary",
    "appliesTo": [
      "any"
    ],
    "description": "Declares which vocabularies a dialect meta-schema uses and whether each is required or optional. Values are objects mapping vocabulary URIs to booleans. Only meaningful in meta-schemas."
  },
  {
    "keyword": "additionalProperties",
    "appliesTo": [
      "object"
    ],
    "description": "Applies to all properties not matched by 'properties' or 'patternProperties'. The value is a schema. If false, any additional property causes validation failure; otherwise each additional property must validate against the given schema."
  },
  {
    "keyword": "allOf",
    "appliesTo": [
      "any"
    ],
    "description": "The instance must validate against every schema in the array. The value is a non-empty array of schemas. All sub-schemas must pass for the overall keyword to pass."
  },
  {
    "keyword": "anyOf",
    "appliesTo": [
      "any"
    ],
    "description": "The instance must validate against at least one schema in the array. The value is a non-empty array of schemas. Validation succeeds if any one sub-schema passes."
  },
  {
    "keyword": "const",
    "appliesTo": [
      "any"
    ],
    "description": "Validates that the instance value is exactly equal to the given value. Uses JSON equality semantics (deep equality for objects and arrays). Useful for enumeration of a single constant."
  },
  {
    "keyword": "contains",
    "appliesTo": [
      "array"
    ],
    "description": "Requires that at least one item in the array validates against the given schema. Works with 'minContains' and 'maxContains' to control how many items must match."
  },
  {
    "keyword": "contentEncoding",
    "appliesTo": [
      "string"
    ],
    "description": "Specifies the encoding of the string instance content, such as 'base64' or '7bit'. Validators may use this to decode the content before validating against contentMediaType or contentSchema."
  },
  {
    "keyword": "contentMediaType",
    "appliesTo": [
      "string"
    ],
    "description": "Indicates the media type (MIME type) of the string instance content, such as 'application/json' or 'text/html'. Annotation-only unless the validator explicitly enables content validation."
  },
  {
    "keyword": "contentSchema",
    "appliesTo": [
      "string"
    ],
    "description": "Provides a schema to validate the decoded content of a string after applying contentEncoding and parsing according to contentMediaType. Annotation-only in most validators."
  },
  {
    "keyword": "default",
    "appliesTo": [
      "any"
    ],
    "description": "Supplies a default value for the instance. The value can be anything. This keyword does not affect validation; it is purely an annotation used by tooling to fill in missing values."
  },
  {
    "keyword": "dependentRequired",
    "appliesTo": [
      "object"
    ],
    "description": "Specifies property dependencies: if a listed property is present, the given set of other properties must also be present. The value is an object mapping property names to arrays of required property names."
  },
  {
    "keyword": "dependentSchemas",
    "appliesTo": [
      "object"
    ],
    "description": "Applies a schema conditionally based on the presence of a property. If a named property is present in the instance, the corresponding schema must also validate. The value is an object mapping property names to schemas."
  },
  {
    "keyword": "deprecated",
    "appliesTo": [
      "any"
    ],
    "description": "Marks the schema as deprecated. The value is a boolean. If true, validators may emit warnings when the instance location matches this schema. Purely an annotation."
  },
  {
    "keyword": "description",
    "appliesTo": [
      "any"
    ],
    "description": "Provides a human-readable description of the schema. The value is a string. Annotation-only; does not affect validation. Useful for documentation generation."
  },
  {
    "keyword": "else",
    "appliesTo": [
      "any"
    ],
    "description": "Applied to the instance only when the 'if' sub-schema fails validation. Forms the false branch of the if/then/else conditional. If 'if' is absent, 'else' has no effect."
  },
  {
    "keyword": "enum",
    "appliesTo": [
      "any"
    ],
    "description": "Validates that the instance value equals one of the values in the array. The array should contain at least one element, and elements should be unique. Uses JSON deep equality."
  },
  {
    "keyword": "examples",
    "appliesTo": [
      "any"
    ],
    "description": "Provides an array of example values that validate against the schema. Annotation-only; does not affect validation. Useful for documentation and UI hinting."
  },
  {
    "keyword": "exclusiveMaximum",
    "appliesTo": [
      "number",
      "integer"
    ],
    "description": "Validates that the numeric instance is strictly less than this value. The value must be a number. Compared using strict inequality (instance < exclusiveMaximum)."
  },
  {
    "keyword": "exclusiveMinimum",
    "appliesTo": [
      "number",
      "integer"
    ],
    "description": "Validates that the numeric instance is strictly greater than this value. The value must be a number. Compared using strict inequality (instance > exclusiveMinimum)."
  },
  {
    "keyword": "format",
    "appliesTo": [
      "string"
    ],
    "description": "Asserts or annotates the expected format of a string instance, such as 'date-time', 'email', 'uri', or 'uuid'. In Draft 2020-12 the format-assertion vocabulary must be explicitly declared; by default format is annotation-only."
  },
  {
    "keyword": "if",
    "appliesTo": [
      "any"
    ],
    "description": "Applies the given schema to the instance and, based on success or failure, determines whether 'then' or 'else' is also applied. The if/then/else trio forms a conditional validation construct."
  },
  {
    "keyword": "items",
    "appliesTo": [
      "array"
    ],
    "description": "Applies a schema to every item in the array. In Draft 2020-12, 'items' applies to items beyond those validated by 'prefixItems' (not to all items). To constrain all items uniformly without a prefix, use 'items' alone."
  },
  {
    "keyword": "maxContains",
    "appliesTo": [
      "array"
    ],
    "description": "Limits the maximum number of items that may validate against the 'contains' schema. The value must be a non-negative integer. Has no effect if 'contains' is absent."
  },
  {
    "keyword": "maxItems",
    "appliesTo": [
      "array"
    ],
    "description": "Validates that the array has at most this many items. The value must be a non-negative integer."
  },
  {
    "keyword": "maxLength",
    "appliesTo": [
      "string"
    ],
    "description": "Validates that the string has at most this many Unicode code points. The value must be a non-negative integer. Length is measured in code points, not bytes or code units."
  },
  {
    "keyword": "maxProperties",
    "appliesTo": [
      "object"
    ],
    "description": "Validates that the object has at most this many properties. The value must be a non-negative integer."
  },
  {
    "keyword": "maximum",
    "appliesTo": [
      "number",
      "integer"
    ],
    "description": "Validates that the numeric instance is less than or equal to this value. The value must be a number. Uses inclusive comparison (instance <= maximum)."
  },
  {
    "keyword": "minContains",
    "appliesTo": [
      "array"
    ],
    "description": "Specifies the minimum number of items that must validate against the 'contains' schema. The value must be a non-negative integer. When set to 0, 'contains' becomes optional. Has no effect if 'contains' is absent."
  },
  {
    "keyword": "minItems",
    "appliesTo": [
      "array"
    ],
    "description": "Validates that the array has at least this many items. The value must be a non-negative integer."
  },
  {
    "keyword": "minLength",
    "appliesTo": [
      "string"
    ],
    "description": "Validates that the string has at least this many Unicode code points. The value must be a non-negative integer."
  },
  {
    "keyword": "minProperties",
    "appliesTo": [
      "object"
    ],
    "description": "Validates that the object has at least this many properties. The value must be a non-negative integer."
  },
  {
    "keyword": "minimum",
    "appliesTo": [
      "number",
      "integer"
    ],
    "description": "Validates that the numeric instance is greater than or equal to this value. The value must be a number. Uses inclusive comparison (instance >= minimum)."
  },
  {
    "keyword": "multipleOf",
    "appliesTo": [
      "number",
      "integer"
    ],
    "description": "Validates that the numeric instance is evenly divisible by this value. The value must be a strictly positive number. Uses the remainder operation: instance % multipleOf == 0."
  },
  {
    "keyword": "not",
    "appliesTo": [
      "any"
    ],
    "description": "Validates that the instance does NOT validate against the given schema. The value is a schema. Passes if and only if the sub-schema fails."
  },
  {
    "keyword": "oneOf",
    "appliesTo": [
      "any"
    ],
    "description": "The instance must validate against exactly one schema in the array. The value is a non-empty array of schemas. Fails if zero or more than one sub-schema passes."
  },
  {
    "keyword": "pattern",
    "appliesTo": [
      "string"
    ],
    "description": "Validates that the string matches the given regular expression. The pattern is an ECMA 262 dialect regular expression. Only needs to match anywhere in the string, not the full string, unless anchors are used."
  },
  {
    "keyword": "patternProperties",
    "appliesTo": [
      "object"
    ],
    "description": "Applies schemas to properties whose names match regular expression patterns. The value is an object mapping regex patterns to schemas. Each property whose name matches a pattern is validated against the corresponding schema."
  },
  {
    "keyword": "prefixItems",
    "appliesTo": [
      "array"
    ],
    "description": "Applies schemas positionally to the first N items in the array. The value is an array of schemas. Item at index i is validated against schema at index i. Items beyond the last prefix schema are validated by 'items' if present."
  },
  {
    "keyword": "properties",
    "appliesTo": [
      "object"
    ],
    "description": "Validates specific named properties of an object. The value is an object mapping property names to schemas. Only properties that exist in the instance are validated; missing properties are not an error by themselves."
  },
  {
    "keyword": "propertyNames",
    "appliesTo": [
      "object"
    ],
    "description": "Validates that every property name in the object satisfies the given schema. The given schema is applied to each property name (a string), not to the property values."
  },
  {
    "keyword": "readOnly",
    "appliesTo": [
      "any"
    ],
    "description": "Indicates that the instance value is read-only and should not be modified. The value is a boolean. Annotation-only; does not affect validation. Useful for API documentation tooling."
  },
  {
    "keyword": "required",
    "appliesTo": [
      "object"
    ],
    "description": "Specifies which properties must be present in the object. The value is an array of unique strings, each being a required property name. Validation fails if any listed property is absent."
  },
  {
    "keyword": "then",
    "appliesTo": [
      "any"
    ],
    "description": "Applied to the instance only when the 'if' sub-schema passes validation. Forms the true branch of the if/then/else conditional. If 'if' is absent, 'then' has no effect."
  },
  {
    "keyword": "title",
    "appliesTo": [
      "any"
    ],
    "description": "Provides a short human-readable title for the schema. The value is a string. Annotation-only; does not affect validation. Used by documentation generators and UI tools."
  },
  {
    "keyword": "type",
    "appliesTo": [
      "any"
    ],
    "description": "Constrains the instance to be of one or more JSON types. The value is either a single type string or an array of type strings. Valid types are: 'null', 'boolean', 'integer', 'number', 'string', 'array', 'object'."
  },
  {
    "keyword": "unevaluatedItems",
    "appliesTo": [
      "array"
    ],
    "description": "Applies a schema to any array items that were not evaluated by 'prefixItems', 'items', or 'contains' in the current schema and any sub-schemas. Useful for tightly closing off additional items in complex composed schemas."
  },
  {
    "keyword": "unevaluatedProperties",
    "appliesTo": [
      "object"
    ],
    "description": "Applies a schema to any properties not evaluated by 'properties', 'patternProperties', or 'additionalProperties' in the current schema and any sub-schemas including allOf, anyOf, etc. More powerful than additionalProperties for composition."
  },
  {
    "keyword": "uniqueItems",
    "appliesTo": [
      "array"
    ],
    "description": "Validates that all items in the array are unique. The value is a boolean. If true, every pair of items must be unequal using JSON deep equality. If false (the default), duplicates are allowed."
  },
  {
    "keyword": "writeOnly",
    "appliesTo": [
      "any"
    ],
    "description": "Indicates that the instance value is write-only and should not be read back. The value is a boolean. Annotation-only; does not affect validation. Common for password fields in API schemas."
  }
] as const;

export type JsonSchemaKeyword = (typeof jsonSchemaKeywords)[number];
