json-schema-typed
Version:
JSON Schema TypeScript definitions with complete inline documentation.
1,398 lines • 66.8 kB
TypeScript
export declare const draft: "2020-12";
export declare const $schema: "https://json-schema.org/draft/2020-12/schema";
type MaybeReadonlyArray<T> = Array<T> | ReadonlyArray<T>;
type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
/** `true` when `T` is a union of two or more members. */
type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
/**
* The `type` names for a schema describing `Value`; every known name for an
* unconstrained value (`any`, `unknown`).
*/
type SchemaTypeFor<Value> = Value extends boolean ? "boolean" : Value extends null ? "null" : Value extends number ? "number" | "integer" : Value extends string ? "string" : Value extends unknown[] ? "array" : Value extends Record<string | number, unknown> ? "object" : JSONSchema.TypeValue;
/**
* The `type` keyword of a permissive `JSONSchema<Value>`: the names for
* `Value`, the list form when there is more than one, and — when `Value` is
* unconstrained — any string, so that schemas whose literal types have been
* widened (e.g. imported from JSON) are still `JSONSchema`s.
*/
type PermissiveSchemaType<Value> = [JSONSchema.TypeValue] extends [
SchemaTypeFor<Value>
] ? JSONSchema.TypeValue | (string & {}) : SchemaTypeFor<Value> | (IsUnion<SchemaTypeFor<Value>> extends true ? MaybeReadonlyArray<SchemaTypeFor<Value>> : never);
/**
* JSON Schema [Draft 2020-12](https://json-schema.org/draft/2020-12/json-schema-validation.html)
*
* A schema is either a boolean or an object of keywords. Every keyword is
* optional and documented inline.
*
* - `JSONSchema` — any schema.
* - `JSONSchema<Value>` — a schema for a particular kind of value; `type` is
* constrained accordingly (`JSONSchema<string>` has `type?: "string"`).
* - `JSONSchema.String`, `JSONSchema.Object`, ... — only the keywords that
* apply to that type.
*/
export type JSONSchema<Value = any, SchemaType = PermissiveSchemaType<Value>> = boolean | JSONSchema.Interface<Value, SchemaType>;
export declare namespace JSONSchema {
/**
* Every value the `type` keyword accepts: a single type name (as a string
* literal or a `TypeName` enum member) or a list of them.
*/
type TypeValue = TypeName | `${TypeName}` | MaybeReadonlyArray<TypeName | `${TypeName}`>;
/**
* The complete set of keywords for this draft. Every keyword is optional.
* The `type` keyword is constrained to `SchemaType`; nested schemas are
* typed as `Sub` (`JSONSchema` unless specified, so that a type extending
* this interface can also be used for nested schemas).
*
* This is the object half of `JSONSchema`; extend it to add custom
* keywords.
*/
interface Interface<Value = any, SchemaType = TypeValue | (string & {}), Sub = JSONSchema> {
/**
* Using JSON Pointer fragments requires knowledge of the structure of the
* schema. When writing schema documents with the intention to provide
* re-usable schemas, it may be preferable to use a plain name fragment that
* is not tied to any particular structural location. This allows a subschema
* to be relocated without requiring JSON Pointer references to be updated.
*
* The `$anchor` keyword is used to specify such a fragment. It is an
* identifier keyword that can only be used to create plain name fragments.
*
* If present, the value of this keyword MUST be a string, which MUST start
* with a letter `[A-Za-z]`, followed by any number of letters, digits
* `[0-9]`, hyphens `-`, underscores `_`, colons `:`, or periods `.`.
*
* Note that the anchor string does not include the `#` character, as it is
* not a URI-reference. An `{"$anchor": "foo"}` becomes the fragment `#foo`
* when used in a URI.
*
* The base URI to which the resulting fragment is appended is determined by
* the `$id` keyword as explained in the previous section. Two `$anchor`
* keywords in the same schema document MAY have the same value if they apply
* to different base URIs, as the resulting full URIs will be distinct.
* However, the effect of two `$anchor` keywords with the same value and the
* same base URI is undefined. Implementations MAY raise an error if such
* usage is detected.
*/
$anchor?: string;
/**
* This keyword reserves a location for comments from schema authors to
* readers or maintainers of the schema.
*
* The value of this keyword MUST be a string. Implementations MUST NOT
* present this string to end users. Tools for editing schemas SHOULD support
* displaying and editing this keyword. The value of this keyword MAY be used
* in debug or error output which is intended for developers making use of
* schemas.
*
* Schema vocabularies SHOULD allow `$comment` within any object containing
* vocabulary keywords. Implementations MAY assume `$comment` is allowed
* unless the vocabulary specifically forbids it. Vocabularies MUST NOT
* specify any effect of `$comment` beyond what is described in this
* specification.
*
* Tools that translate other media types or programming languages to and from
* `application/schema+json` MAY choose to convert that media type or
* programming language's native comments to or from `$comment` values. The
* behavior of such translation when both native comments and `$comment`
* properties are present is implementation-dependent.
*
* Implementations MAY strip `$comment` values at any point during processing.
* In particular, this allows for shortening schemas when the size of deployed
* schemas is a concern.
*
* Implementations MUST NOT take any other action based on the presence,
* absence, or contents of `$comment` properties. In particular, the value of
* `$comment` MUST NOT be collected as an annotation result.
*/
$comment?: string;
/**
* The `$defs` keyword reserves a location for schema authors to inline
* re-usable JSON Schemas into a more general schema. The keyword does not
* directly affect the validation result.
*
* This keyword's value MUST be an object. Each member value of this object
* MUST be a valid JSON Schema.
*/
$defs?: Record<string, Sub>;
/**
* The `$dynamicAnchor` indicates that the fragment is an extension point when
* used with the `$dynamicRef` keyword. This low-level, advanced feature makes
* it easier to extend recursive schemas such as the meta-schemas, without
* imposing any particular semantics on that extension. See `$dynamicRef` for
* more details.
*/
$dynamicAnchor?: string;
/**
* The `$dynamicRef` keyword is an applicator that allows for deferring the
* full resolution until runtime, at which point it is resolved each time it
* is encountered while evaluating an instance.
*
* Together with `$dynamicAnchor`, `$dynamicRef` implements a cooperative
* extension mechanism that is primarily useful with recursive schemas
* (schemas that reference themselves). Both the extension point and the
* runtime-determined extension target are defined with `$dynamicAnchor`, and
* only exhibit runtime dynamic behavior when referenced with `$dynamicRef`.
*
* The value of the `$dynamicRef` property MUST be a string which is a
* URI-Reference. Resolved against the current URI base, it produces the URI
* used as the starting point for runtime resolution. This initial resolution
* is safe to perform on schema load.
*
* If the initially resolved starting point URI includes a fragment that was
* created by the `$dynamicAnchor` keyword, the initial URI MUST be replaced
* by the URI (including the fragment) for the outermost schema resource in
* the [dynamic scope][scopes] that defines an identically named fragment with
* `$dynamicAnchor`.
*
* Otherwise, its behavior is identical to `$ref`, and no runtime resolution
* is needed.
*
* [scopes]:
* https://json-schema.org/draft/2020-12/json-schema-core.html#scopes
*
*
*
* @format "uri-reference"
*/
$dynamicRef?: string;
/**
* The `$id` keyword identifies a schema resource with its
* [canonical][RFC6596] URI.
*
* Note that this URI is an identifier and not necessarily a network locator.
* In the case of a network-addressable URL, a schema need not be downloadable
* from its canonical URI.
*
* If present, the value for this keyword MUST be a string, and MUST represent
* a valid [URI-reference][RFC3986]. This URI-reference SHOULD be normalized,
* and MUST resolve to an [absolute-URI][RFC3986] (without a fragment), or to
* a URI with an empty fragment.
*
* The empty fragment form is NOT RECOMMENDED and is retained only for
* backwards compatibility, and because the `application/schema+json` media
* type defines that a URI with an empty fragment identifies the same resource
* as the same URI with the fragment removed. However, since this equivalence
* is not part of the [RFC 3986 normalization process][RFC3986], implementers
* and schema authors cannot rely on generic URI libraries understanding it.
*
* Therefore, `$id` MUST NOT contain a non-empty fragment, and SHOULD NOT
* contain an empty fragment. The absolute-URI form MUST be considered the
* canonical URI, regardless of the presence or absence of an empty fragment.
*
* The absolute-URI also serves as the base URI for relative URI-references in
* keywords within the schema resource, in accordance with [RFC 3986][RFC3986]
* section 5.1.1 regarding base URIs embedded in content.
*
* The presence of `$id` in a subschema indicates that the subschema
* constitutes a distinct schema resource within a single schema document.
* Furthermore, in accordance with [RFC 3986][RFC3986] section 5.1.2 regarding
* encapsulating entities, if an `$id` in a subschema is a relative
* URI-reference, the base URI for resolving that reference is the URI of the
* parent schema resource.
*
* If no parent schema object explicitly identifies itself as a resource with
* `$id`, the base URI is that of the entire document.
*
* The root schema of a JSON Schema document SHOULD contain an `$id` keyword
* with an [absolute-URI][RFC3986] (containing a scheme, but no fragment).
*
* [RFC6596]: https://datatracker.ietf.org/doc/html/rfc6596
* [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
*
*
*
* @format "uri-reference"
*/
$id?: string;
/**
* Draft 2019-09 keyword, replaced by `$dynamicAnchor` in draft 2020-12. It is
* still listed in the draft 2020-12 meta-schema for compatibility.
*
*
*
* @default false
* @deprecated `$recursiveAnchor` has been replaced by `$dynamicAnchor`.
*/
$recursiveAnchor?: boolean;
/**
* Draft 2019-09 keyword, replaced by `$dynamicRef` in draft 2020-12. It is
* still listed in the draft 2020-12 meta-schema for compatibility.
*
*
*
* @deprecated `$recursiveRef` has been replaced by `$dynamicRef`.
* @format "uri-reference"
*/
$recursiveRef?: string;
/**
* The `$ref` keyword is an applicator that is used to reference a statically
* identified schema. Its results are the results of the referenced schema.
* Other keywords can appear alongside of `$ref` in the same schema object.
*
* The value of the `$ref` property MUST be a string which is a URI-Reference.
* Resolved against the current URI base, it produces the URI of the schema to
* apply.
*
*
*
* @format "uri-reference"
*/
$ref?: string;
/**
* The `$schema` keyword is both used as a JSON Schema dialect identifier and
* as the identifier of a resource which is itself a JSON Schema, which
* describes the set of valid schemas written for this particular dialect.
*
* The value of this keyword MUST be a [URI][RFC3986] (containing a scheme)
* and this URI MUST be normalized. The current schema MUST be valid against
* the meta-schema identified by this URI.
*
* If this URI identifies a retrievable resource, that resource SHOULD be of
* media type `application/schema+json`.
*
* The `$schema` keyword SHOULD be used in the document root schema object,
* and MAY be used in the root schema objects of embedded schema resources. It
* MUST NOT appear in non-resource root schema objects. If absent from the
* document root schema, the resulting behavior is implementation-defined.
*
* Values for this property are defined elsewhere in this and other documents,
* and by other parties.
*
* [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
*
*
*
* @format "uri"
*/
$schema?: string;
/**
* The `$vocabulary` keyword is used in meta-schemas to identify the
* vocabularies available for use in schemas described by that meta-schema. It
* is also used to indicate whether each vocabulary is required or optional,
* in the sense that an implementation MUST understand the required
* vocabularies in order to successfully process the schema. Together, this
* information forms a dialect. Any vocabulary that is understood by the
* implementation MUST be processed in a manner consistent with the semantic
* definitions contained within the vocabulary.
*
* The value of this keyword MUST be an object. The property names in the
* object MUST be URIs (containing a scheme) and this URI MUST be normalized.
* Each URI that appears as a property name identifies a specific set of
* keywords and their semantics.
*
* The URI MAY be a URL, but the nature of the retrievable resource is
* currently undefined, and reserved for future use. Vocabulary authors MAY
* use the URL of the vocabulary specification, in a human-readable media type
* such as `text/html` or `text/plain`, as the vocabulary URI.
*
* The values of the object properties MUST be booleans. If the value is
* `true`, then implementations that do not recognize the vocabulary MUST
* refuse to process any schemas that declare this meta-schema with `$schema`.
* If the value is `false`, implementations that do not recognize the
* vocabulary SHOULD proceed with processing such schemas. The value has no
* impact if the implementation understands the vocabulary.
*
* Unrecognized keywords SHOULD be ignored. This remains the case for keywords
* defined by unrecognized vocabularies. It is not currently possible to
* distinguish between unrecognized keywords that are defined in vocabularies
* from those that are not part of any vocabulary.
*
* The `$vocabulary` keyword SHOULD be used in the root schema of any schema
* document intended for use as a meta-schema. It MUST NOT appear in
* subschemas.
*
* The `$vocabulary` keyword MUST be ignored in schema documents that are not
* being processed as a meta-schema.
*/
$vocabulary?: Record<string, boolean>;
/**
*
*
*
* @deprecated `additionalItems` has been deprecated in favor of `prefixItems`
* paired with `items`.
*/
additionalItems?: Sub;
/**
* The value of `additionalProperties` MUST be a valid JSON Schema.
*
* The behavior of this keyword depends on the presence and annotation results
* of `properties` and `patternProperties` within the same schema object.
* Validation with `additionalProperties` applies only to the child values of
* instance names that do not appear in the annotation results of either
* `properties` or `patternProperties`.
*
* For all such properties, validation succeeds if the child instance
* validates against the `additionalProperties` schema.
*
* The annotation result of this keyword is the set of instance property names
* validated by this keyword's subschema. Annotation results for
* `additionalProperties` keywords from multiple schemas applied to the same
* instance location are combined by taking the union of the sets. This
* annotation affects the behavior of `unevaluatedProperties` in the
* Unevaluated vocabulary.
*
* Omitting this keyword has the same assertion behavior as an empty schema.
*
* Implementations MAY choose to implement or optimize this keyword in another
* way that produces the same effect, such as by directly checking the names
* in `properties` and the patterns in `patternProperties` against the
* instance property set.
*/
additionalProperties?: Sub;
/**
* This keyword's value MUST be a non-empty array. Each item of the array MUST
* be a valid JSON Schema.
*
* An instance validates successfully against this keyword if it validates
* successfully against all schemas defined by this keyword's value.
*/
allOf?: MaybeReadonlyArray<Sub>;
/**
* This keyword's value MUST be a non-empty array. Each item of the array MUST
* be a valid JSON Schema.
*
* An instance validates successfully against this keyword if it validates
* successfully against at least one schema defined by this keyword's value.
*/
anyOf?: MaybeReadonlyArray<Sub>;
/**
* An instance validates successfully against this keyword if its value is
* equal to the value of the keyword.
*
* Use of this keyword is functionally equivalent to the `enum` keyword with a
* single value.
*/
const?: Value;
/**
* The value of this keyword MUST be a valid JSON Schema.
*
* An array instance is valid against `contains` if at least one of its
* elements is valid against the given schema, except when `minContains` is
* present and has a value of `0`, in which case an array instance MUST be
* considered valid against the `contains` keyword, even if none of its
* elements is valid against the given schema.
*
* This keyword produces an annotation value which is an array of the indexes
* to which this keyword validates successfully when applying its subschema,
* in ascending order. The value MAY be a boolean `true` if the subschema
* validates successfully when applied to every index of the instance. The
* annotation MUST be present if the instance array to which this keyword's
* schema applies is empty.
*
* This annotation affects the behavior of `unevaluatedItems` in the
* Unevaluated vocabulary, and MAY also be used to implement the `minContains`
* and `maxContains` keywords in the Validation vocabulary.
*
* The subschema MUST be applied to every array element even after the first
* match has been found, in order to collect annotations for use by other
* keywords. This is to ensure that all possible annotations are collected.
*/
contains?: Sub;
/**
* If the instance value is a string, this property defines that the string
* SHOULD be interpreted as encoded binary data and decoded using the encoding
* named by this property.
*
* Possible values indicating base 16, 32, and 64 encodings with several
* variations are listed in [RFC 4648][RFC4648]. Additionally, sections 6.7
* and 6.8 of [RFC 2045][RFC2045] provide encodings used in MIME. This keyword
* is derived from MIME's Content-Transfer-Encoding header, which was designed
* to map binary data into ASCII characters. It is not related to HTTP's
* Content-Encoding header, which is used to encode (e.g. compress or encrypt)
* the content of HTTP request and responses.
*
* As `"base64"` is defined in both RFCs, the definition from RFC 4648 SHOULD
* be assumed unless the string is specifically intended for use in a MIME
* context. Note that all of these encodings result in strings consisting only
* of 7-bit ASCII characters. Therefore, this keyword has no meaning for
* strings containing characters outside of that range.
*
* If this keyword is absent, but `contentMediaType` is present, this
* indicates that the encoding is the identity encoding, meaning that no
* transformation was needed in order to represent the content in a UTF-8
* string.
*
* The value of this property MUST be a string.
*
* The `ContentEncoding` enum lists the well-known values.
*
* [RFC2045]: https://datatracker.ietf.org/doc/html/rfc2045#section-6.7
* [RFC4648]: https://datatracker.ietf.org/doc/html/rfc4648
*/
contentEncoding?: string;
/**
* If the instance is a string, this property indicates the media type of the
* contents of the string. If `contentEncoding` is present, this property
* describes the decoded string.
*
* The value of this property must be a media type, as defined by [RFC
* 2046][RFC2046]. This property defines the media type of instances which
* this schema defines.
*
* The value of this property SHOULD be ignored if the instance described is
* not a string.
*
* If the `contentEncoding` property is not present, but the instance value is
* a string, then the value of this property SHOULD specify a text document
* type, and the character set SHOULD be the character set into which the JSON
* string value was decoded (for which the default is Unicode).
*
* [RFC2046]: https://datatracker.ietf.org/doc/html/rfc2046
*/
contentMediaType?: string;
/**
* If the instance is a string, and if `contentMediaType` is present, this
* property contains a schema which describes the structure of the string.
*
* This keyword MAY be used with any media type that can be mapped into JSON
* Schema's data model.
*
* The value of this property MUST be a valid JSON schema. It SHOULD be
* ignored if `contentMediaType` is not present.
*/
contentSchema?: Sub;
/**
* This keyword can be used to supply a default JSON value associated with a
* particular schema. It is RECOMMENDED that a `default` value be valid
* against the associated schema.
*/
default?: Value;
/**
*
*
*
* @deprecated `definitions` has been renamed to `$defs`.
*/
definitions?: Record<string, Sub>;
/**
*
*
*
* @deprecated `dependencies` has been split into two keywords:
* `dependentSchemas` and `dependentRequired`.
*/
dependencies?: Record<string, MaybeReadonlyArray<string> | Sub>;
/**
* The value of this keyword MUST be an object. Properties in this object, if
* any, MUST be arrays. Elements in each array, if any, MUST be strings, and
* MUST be unique.
*
* This keyword specifies properties that are required if a specific other
* property is present. Their requirement is dependent on the presence of the
* other property.
*
* Validation succeeds if, for each name that appears in both the instance and
* as a name within this keyword's value, every item in the corresponding
* array is also the name of a property in the instance.
*
* Omitting this keyword has the same behavior as an empty object.
*/
dependentRequired?: Record<string, MaybeReadonlyArray<string>>;
/**
* This keyword specifies subschemas that are evaluated if the instance is an
* object and contains a certain property.
*
* This keyword's value MUST be an object. Each value in the object MUST be a
* valid JSON Schema.
*
* If the object key is a property in the instance, the entire instance must
* validate against the subschema. Its use is dependent on the presence of the
* property.
*
* Omitting this keyword has the same behavior as an empty object.
*/
dependentSchemas?: Record<string, Sub>;
/**
* The value of this keyword MUST be a boolean. When multiple occurrences of
* this keyword are applicable to a single sub-instance, applications SHOULD
* consider the instance location to be deprecated if any occurrence specifies
* a `true` value.
*
* If `deprecated` has a value of boolean `true`, it indicates that
* applications SHOULD refrain from usage of the declared property. It MAY
* mean the property is going to be removed in the future.
*
* A root schema containing `deprecated` with a value of `true` indicates that
* the entire resource being described MAY be removed in the future.
*
* The `deprecated` keyword applies to each instance location to which the
* schema object containing the keyword successfully applies. This can result
* in scenarios where every array item or object property is deprecated even
* though the containing array or object is not.
*
* Omitting this keyword has the same behavior as a value of `false`.
*
*
*
* @default false
*/
deprecated?: boolean;
/**
* Can be used to decorate a user interface with explanation or information
* about the data produced.
*/
description?: string;
/**
* This keyword's value MUST be a valid JSON Schema.
*
* When `if` is present, and the instance fails to validate against its
* subschema, then validation succeeds against this keyword if the instance
* successfully validates against this keyword's subschema.
*
* This keyword has no effect when `if` is absent, or when the instance
* successfully validates against its subschema. Implementations MUST NOT
* evaluate the instance against this keyword, for either validation or
* annotation collection purposes, in such cases.
*/
else?: Sub;
/**
* The value of this keyword MUST be an array. This array SHOULD have at least
* one element. Elements in the array SHOULD be unique.
*
* An instance validates successfully against this keyword if its value is
* equal to one of the elements in this keyword's array value.
*
* Elements in the array might be of any type, including `null`.
*/
enum?: MaybeReadonlyArray<Value>;
/**
* The value of this keyword MUST be an array. When multiple occurrences of
* this keyword are applicable to a single sub-instance, implementations MUST
* provide a flat array of all values rather than an array of arrays.
*
* This keyword can be used to provide sample JSON values associated with a
* particular schema, for the purpose of illustrating usage. It is RECOMMENDED
* that these values be valid against the associated schema.
*
* Implementations MAY use the value(s) of `default`, if present, as an
* additional example. If `examples` is absent, `default` MAY still be used in
* this manner.
*/
examples?: MaybeReadonlyArray<Value>;
/**
* The value of `exclusiveMaximum` MUST be a number, representing an exclusive
* upper limit for a numeric instance.
*
* If the instance is a number, then the instance is valid only if it has a
* value strictly less than (not equal to) `exclusiveMaximum`.
*/
exclusiveMaximum?: number;
/**
* The value of `exclusiveMinimum` MUST be a number, representing an exclusive
* lower limit for a numeric instance.
*
* If the instance is a number, then the instance is valid only if it has a
* value strictly greater than (not equal to) `exclusiveMinimum`.
*/
exclusiveMinimum?: number;
/**
* Implementations MAY treat `format` as an assertion in addition to an
* annotation, and attempt to validate the value's conformance to the
* specified semantics.
*
* The value of this keyword is called a format attribute. It MUST be a
* string. A format attribute can generally only validate a given set of
* instance types. If the type of the instance to validate is not in this set,
* validation for this format attribute and instance SHOULD succeed. Format
* attributes are most often applied to strings, but can be specified to apply
* to any type.
*
* Implementations MAY support custom format attributes. Save for agreement
* between parties, schema authors SHALL NOT expect a peer implementation to
* support such custom format attributes. An implementation MUST NOT fail
* validation or cease processing due to an unknown format attribute. When
* treating `format` as an annotation, implementations SHOULD collect both
* known and unknown format attribute values.
*/
format?: string;
/**
* This keyword's value MUST be a valid JSON Schema.
*
* This validation outcome of this keyword's subschema has no direct effect on
* the overall validation result. Rather, it controls which of the `then` or
* `else` keywords are evaluated.
*
* Instances that successfully validate against this keyword's subschema MUST
* also be valid against the subschema value of the `then` keyword, if
* present.
*
* Instances that fail to validate against this keyword's subschema MUST also
* be valid against the subschema value of the `else` keyword, if present.
*
* If annotations are being collected, they are collected from this keyword's
* subschema in the usual way, including when the keyword is present without
* either `then` or `else`.
*/
if?: Sub;
/**
* The value of `items` MUST be a valid JSON Schema.
*
* This keyword applies its subschema to all instance elements at indexes
* greater than the length of the `prefixItems` array in the same schema
* object, as reported by the annotation result of that `prefixItems` keyword.
* If no such annotation result exists, `items` applies its subschema to all
* instance array elements.
*
* Note that the behavior of `items` without `prefixItems` is identical to
* that of the schema form of `items` in prior drafts.
*
* When `prefixItems` is present, the behavior of `items` is identical to the
* former `additionalItems` keyword.
*
* If the `items` subschema is applied to any positions within the instance
* array, it produces an annotation result of boolean `true`, indicating that
* all remaining array elements have been evaluated against this keyword's
* subschema. This annotation affects the behavior of `unevaluatedItems` in
* the Unevaluated vocabulary.
*
* Omitting this keyword has the same assertion behavior as an empty schema.
*
* Implementations MAY choose to implement or optimize this keyword in another
* way that produces the same effect, such as by directly checking for the
* presence and size of a `prefixItems` array.
*/
items?: Sub;
/**
* The value of this keyword MUST be a non-negative integer.
*
* If `contains` is not present within the same schema object, then this
* keyword has no effect.
*
* An instance array is valid against `maxContains` in two ways, depending on
* the form of the annotation result of an adjacent `contains` keyword. The
* first way is if the annotation result is an array and the length of that
* array is less than or equal to the `maxContains` value. The second way is
* if the annotation result is a boolean `true` and the instance array length
* is less than or equal to the `maxContains` value.
*
*
*
* @minimum 0
*/
maxContains?: number;
/**
* The value of `maximum` MUST be a number, representing an inclusive upper
* limit for a numeric instance.
*
* If the instance is a number, then this keyword validates only if the
* instance is less than or exactly equal to `maximum`.
*/
maximum?: number;
/**
* The value of this keyword MUST be a non-negative integer.
*
* An array instance is valid against `maxItems` if its size is less than, or
* equal to, the value of this keyword.
*
*
*
* @minimum 0
*/
maxItems?: number;
/**
* The value of this keyword MUST be a non-negative integer.
*
* A string instance is valid against this keyword if its length is less than,
* or equal to, the value of this keyword.
*
* The length of a string instance is defined as the number of its characters
* as defined by [RFC 8259][RFC8259].
*
* [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
*
*
*
* @minimum 0
*/
maxLength?: number;
/**
* The value of this keyword MUST be a non-negative integer.
*
* An object instance is valid against `maxProperties` if its number of
* `properties` is less than, or equal to, the value of this keyword.
*
*
*
* @minimum 0
*/
maxProperties?: number;
/**
* The value of this keyword MUST be a non-negative integer.
*
* If `contains` is not present within the same schema object, then this
* keyword has no effect.
*
* An instance array is valid against `minContains` in two ways, depending on
* the form of the annotation result of an adjacent `contains` keyword. The
* first way is if the annotation result is an array and the length of that
* array is greater than or equal to the `minContains` value. The second way
* is if the annotation result is a boolean `true` and the instance array
* length is greater than or equal to the `minContains` value.
*
* A value of `0` is allowed, but is only useful for setting a range of
* occurrences from `0` to the value of `maxContains`. A value of `0` causes
* `minContains` and `contains` to always pass validation (but validation can
* still fail against a `maxContains` keyword).
*
* Omitting this keyword has the same behavior as a value of `1`.
*
*
*
* @default 1
* @minimum 0
*/
minContains?: number;
/**
* The value of `minimum` MUST be a number, representing an inclusive lower
* limit for a numeric instance.
*
* If the instance is a number, then this keyword validates only if the
* instance is greater than or exactly equal to `minimum`.
*/
minimum?: number;
/**
* The value of this keyword MUST be a non-negative integer.
*
* An array instance is valid against `minItems` if its size is greater than,
* or equal to, the value of this keyword.
*
* Omitting this keyword has the same behavior as a value of `0`.
*
*
*
* @default 0
* @minimum 0
*/
minItems?: number;
/**
* The value of this keyword MUST be a non-negative integer.
*
* A string instance is valid against this keyword if its length is greater
* than, or equal to, the value of this keyword.
*
* The length of a string instance is defined as the number of its characters
* as defined by [RFC 8259][RFC8259].
*
* Omitting this keyword has the same behavior as a value of `0`.
*
* [RFC8259]: https://datatracker.ietf.org/doc/html/rfc8259
*
*
*
* @default 0
* @minimum 0
*/
minLength?: number;
/**
* The value of this keyword MUST be a non-negative integer.
*
* An object instance is valid against `minProperties` if its number of
* `properties` is greater than, or equal to, the value of this keyword.
*
* Omitting this keyword has the same behavior as a value of `0`.
*
*
*
* @default 0
* @minimum 0
*/
minProperties?: number;
/**
* The value of `multipleOf` MUST be a number, strictly greater than `0`.
*
* A numeric instance is valid only if division by this keyword's value
* results in an integer.
*
*
*
* @exclusiveMinimum 0
*/
multipleOf?: number;
/**
* This keyword's value MUST be a valid JSON Schema.
*
* An instance is valid against this keyword if it fails to validate
* successfully against the schema defined by this keyword.
*/
not?: Sub;
/**
* This keyword's value MUST be a non-empty array. Each item of the array MUST
* be a valid JSON Schema.
*
* An instance validates successfully against this keyword if it validates
* successfully against exactly one schema defined by this keyword's value.
*/
oneOf?: MaybeReadonlyArray<Sub>;
/**
* The value of this keyword MUST be a string. This string SHOULD be a valid
* regular expression, according to the [ECMA-262][ecma262] regular expression
* dialect.
*
* A string instance is considered valid if the regular expression matches the
* instance successfully. Recall: regular expressions are not implicitly
* anchored.
*
* [ecma262]:
* https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
*
*
*
* @format "regex"
*/
pattern?: string;
/**
* The value of `patternProperties` MUST be an object. Each property name of
* this object SHOULD be a valid regular expression, according to the
* [ECMA-262][ecma262] regular expression dialect. Each property value of this
* object MUST be a valid JSON Schema.
*
* Validation succeeds if, for each instance name that matches any regular
* expressions that appear as a property name in this keyword's value, the
* child instance for that name successfully validates against each schema
* that corresponds to a matching regular expression.
*
* The annotation result of this keyword is the set of instance property names
* matched by this keyword. This annotation affects the behavior of
* `additionalProperties` (in this vocabulary) and `unevaluatedProperties` (in
* the Unevaluated vocabulary). Omitting this keyword has the same assertion
* behavior as an empty object.
*
* [ecma262]:
* https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
*/
patternProperties?: Record<string, Sub>;
/**
* The value of `prefixItems` MUST be a non-empty array of valid JSON Schemas.
*
* Validation succeeds if each element of the instance validates against the
* schema at the same position, if any. This keyword does not constrain the
* length of the array. If the array is longer than this keyword's value, this
* keyword validates only the prefix of matching length.
*
* This keyword produces an annotation value which is the largest index to
* which this keyword applied a subschema. The value MAY be a boolean `true`
* if a subschema was applied to every index of the instance, such as is
* produced by the `items` keyword. This annotation affects the behavior of
* `items` and `unevaluatedItems`.
*
* Omitting this keyword has the same assertion behavior as an empty array.
*/
prefixItems?: MaybeReadonlyArray<Sub>;
/**
* The value of `properties` MUST be an object. Each value of this object MUST
* be a valid JSON Schema.
*
* Validation succeeds if, for each name that appears in both the instance and
* as a name within this keyword's value, the child instance for that name
* successfully validates against the corresponding schema.
*
* The annotation result of this keyword is the set of instance property names
* matched by this keyword. This annotation affects the behavior of
* `additionalProperties` (in this vocabulary) and `unevaluatedProperties` in
* the Unevaluated vocabulary.
*
* Omitting this keyword has the same assertion behavior as an empty object.
*/
properties?: Record<string, Sub>;
/**
* The value of `propertyNames` MUST be a valid JSON Schema.
*
* If the instance is an object, this keyword validates if every property name
* in the instance validates against the provided schema. Note the property
* name that the schema is testing will always be a string.
*
* Omitting this keyword has the same behavior as an empty schema.
*/
propertyNames?: Sub;
/**
* The value of this keyword MUST be a boolean. When multiple occurrences of
* this keyword are applicable to a single sub-instance, the resulting value
* MUST be `true` if any occurrence specifies a `true` value, and MUST be
* `false` otherwise.
*
* If `readOnly` has a value of boolean `true`, it indicates that the value of
* the instance is managed exclusively by the owning authority, and attempts
* by an application to modify the value of this property are expected to be
* ignored or rejected by that owning authority.
*
* An instance document that is marked as `readOnly` for the entire document
* MAY be ignored if sent to the owning authority, or MAY result in an error,
* at the authority's discretion.
*
* For example, `readOnly` would be used to mark a database-generated serial
* number as read-only.
*
* This keyword can be used to assist in user interface instance generation.
*
*
*
* @default false
*/
readOnly?: boolean;
/**
* The value of this keyword MUST be an array. Elements of this array, if any,
* MUST be strings, and MUST be unique.
*
* An object instance is valid against this keyword if every item in the array
* is the name of a property in the instance.
*
* Omitting this keyword has the same behavior as an empty array.
*/
required?: MaybeReadonlyArray<string>;
/**
* This keyword's value MUST be a valid JSON Schema.
*
* When `if` is present, and the instance successfully validates against its
* subschema, then validation succeeds against this keyword if the instance
* also successfully validates against this keyword's subschema.
*
* This keyword has no effect when `if` is absent, or when the instance fails
* to validate against its subschema. Implementations MUST NOT evaluate the
* instance against this keyword, for either validation or annotation
* collection purposes, in such cases.
*/
then?: Sub;
/**
* Can be used to decorate a user interface with a short label about the data
* produced.
*/
title?: string;
/**
* The value of this keyword MUST be either a string or an array. If it is an
* array, elements of the array MUST be strings and MUST be unique.
*
* String values MUST be one of the six primitive types (`"null"`,
* `"boolean"`, `"object"`, `"array"`, `"number"`, or `"string"`), or
* `"integer"` which matches any number with a zero fractional part.
*
* If the value of `type` is a string, then an instance validates successfully
* if its type matches the type represented by the value of the string.
*
* If the value of `type` is an array, then an instance validates successfully
* if its type matches any of the types indicated by the strings in the array.
*/
type?: SchemaType;
/**
* The value of `unevaluatedItems` MUST be a valid JSON Schema.
*
* The behavior of this keyword depends on the annotation results of adjacent
* keywords that apply to the instance location being validated. Specifically,
* the annotations from `prefixItems`, `items`, and `contains`, which can come
* from those keywords when they are adjacent to the `unevaluatedItems`
* keyword. Those three annotations, as well as `unevaluatedItems`, can also
* result from any and all adjacent [in-place applicator][in-place-applicator]
* keywords.
*
* If no relevant annotations are present, the `unevaluatedItems` subschema
* MUST be applied to all locations in the array. If a boolean `true` value is
* present from any of the relevant annotations, `unevaluatedItems` MUST be
* ignored. Otherwise, the subschema MUST be applied to any index greater than
* the largest annotation value for `prefixItems`, which does not appear in
* any annotation value for `contains`.
*
* This means that `prefixItems`, `items`, `contains`, and all in-place
* applicators MUST be evaluated before this keyword can be evaluated. Authors
* of extension keywords MUST NOT define an in-place applicator that would
* need to be evaluated after this keyword.
*
* If the `unevaluatedItems` subschema is applied to any positions within the
* instance array, it produces an annotation result of boolean `true`,
* analogous to the behavior of `items`. This annotation affects the behavior
* of `unevaluatedItems` in parent schemas.
*
* Omitting this keyword has the same assertion behavior as an empty schema.
*
* [in-place-applicator]:
* https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
*/
unevaluatedItems?: Sub;
/**
* The value of `unevaluatedProperties` MUST be a valid JSON Schema.
*
* The behavior of this keyword depends on the annotation results of adjacent
* keywords that apply to the instance location being validated. Specifically,
* the annotations from `properties`, `patternProperties`, and
* `additionalProperties`, which can come from those keywords when they are
* adjacent to the `unevaluatedProperties` keyword. Those three annotations,
* as well as `unevaluatedProperties`, can also result from any and all
* adjacent [in-place applicator][in-place-applicator] keywords.
*
* Validation with `unevaluatedProperties` applies only to the child values of
* instance names that do not appear in the `properties`, `patternProperties`,
* `additionalProperties`, or `unevaluatedProperties` annotation results that
* apply to the instance location being validated.
*
* For all such properties, validation succeeds if the child instance
* validates against the "unevaluatedProperties" schema.
*
* This means that `properties`, `patternProperties`, `additionalProperties`,
* and all in-place applicators MUST be evaluated before this keyword can be
* evaluated. Authors of extension keywords MUST NOT define an in-place
* applicator that would need to be evaluated after this keyword.
*
* The annotation result of this keyword is the set of instance property names
* validated by this keyword's subschema. This annotation affects the behavior
* of `unevaluatedProperties` in parent schemas.
*
* Omitting this keyword has the same assertion behavior as an empty schema.
*
* [in-place-applicator]:
* https://json-schema.org/draft/2020-12/json-schema-core.html#in-place
*/
unevaluatedProperties?: Sub;
/**
* The value of this keyword MUST be a boolean.
*
* If this keyword has boolean value `false`, the instance validates
* successfully. If it has boolean value `true`, the instance validates
* successfully if all of its elements are unique.
*
* Omitting this keyword has the same behavior as a value of `false`.
*
*
*
* @default false
*/
uniqueItems?: boolean;
/**
* The value of this keyword MUST be a boolean. When multiple occurrences of
* this keyword is applicable to a single sub-instance, the resulting value
* MUST be `true` if any occurrence specifies a `true` value, and MUST be
* `false` otherwise.
*
* If `writeOnly` has a value of boolean `true`, it indicates that the value
* is never present when the instance is retrieved from the owning authority.
* It can be present when sent to the owning authority to update or create the
* document (or the resource it represents), but it will not be included in
* any updated or newly created version of the instance.
*
* An instance document that is marked as `writeOnly` for the entire document
* MAY be returned as a blank document of some sort, or MAY produce an error
* upon retrieval, or have the retrieval request ignored, at the authority's
* discretion.
*
* For example, `writeOnly` would be used to mark a password input field.
*
* These keywords can be used to assist in user interface instance generation.
* In particular, an application MAY choose to use a widget that hides input
* values as they are typed for write-only fields.
*
*
*
* @default false
*/
writeOnly?: boolean;
}
/**
* The keywords permitted for a given `type` value. Keywords shared by every
* type are always included; type-specific keywords are included when
* `SchemaType` contains that type. A list of type names permits the
* keywords of every type in the list.
*/
type KeywordsFor<SchemaType extends TypeValue> = KeywordByType.Any | (SchemaType extends "array" ? KeywordByType.Array : never) | (SchemaType extends "integer" | "number" ? KeywordByType.Number : never) | (SchemaType extends "object" ? KeywordByType.Object : never) | (SchemaType extends "string" ? KeywordByType.String : never) | (SchemaType extends MaybeReadonlyArray<unknown> ? keyof Interface : never);
/**
* A schema object with only the keywords that apply to `SchemaType`.
* `JSONSchema.String`, `JSONSchema.Object`, etc. are instances of this.
*/
type Narrowed<Value, SchemaType extends TypeValue, Sub = JSONSchema> = Pick<Interface<Value, SchemaType, Sub>, KeywordsFor<SchemaType>>;
type Array<T = any> = Narrowed<T, "array">;
type Boolean = Narrowed<boolean, "boolean">;
type Integer = Narrowed<number, "integer">;
type Number = Narrowed<number, "number">;
type Null = Narrowed<null, "null">;
type Object<T = any> = Narrowed<T, "object">;
type String = Narrowed<string, "string">;
}
/**
* Keyword names grouped by the `type` they apply to. `Any` applies to every
* type.
*/
export declare namespace KeywordByType {
type Any = "$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$recursiveAnchor" | "$recursiveRef" | "$ref" | "$schema" | "$vocabulary" | "allOf" | "anyOf" | "const" | "default" | "definitions" | "deprecated" | "description" | "else" | "enum" | "examples" | "format" | "if" | "not" | "oneOf" | "readOnly" | "then" | "title" | "type" | "writeOnly";
type Array = "additionalItems" | "contains" | "items" | "maxContains" | "maxItems" | "minContains" | "minItems" | "prefixItems" | "unevaluatedItems" | "uniqueItems";
type Number = "exclusiveMaximum" | "exclusiveMinimum" | "maximum" | "minimum" | "multipleOf";
type Object = "additionalProperties" | "dependencies" | "dependentRequired" | "dependentSchemas" | "maxProperties" | "minProperties" | "patternProperties" | "properties" | "propertyNames" | "required" | "unevaluatedProperties";
type String = "contentEncoding" | "contentMediaType" | "contentSchema" | "maxLength" | "minLength" | "pattern";
}
/**
* Content encoding strategy enum.
*
* - [RFC 4648: The Base16, Base32, and Base64 Data Encodings](https://datatracker.ietf.org/doc/html/rfc4648)
* - [Content-Transfer-Encoding Syntax](https://datatracker.ietf.org/doc/html/rfc2045#section-6.1)
* - [7bit vs 8bit encoding](https://stackoverflow.com/questions/25710599/content-transfer-encoding-7bit-or-8-bit/28531705#28531705)
*/
export declare enum ContentEncoding {
/**
* Only US-ASCII characters, which use the lower 7 bits for each character.
*
* Each line must be less than 1,000 characters.
*/
"7bit" = "7bit",
/**
* Allow extended ASCII characters which can use the 8th (highest) bit to
* indicate special characters not available in 7bit.
*
* Each line must be less than 1,000 characters.
*/
"8bit" = "8bit",
/**
* Hexadecimal encoding using the alphabet `0-9A-F`, as defined by
* [RFC 4648, Section 8](https://datatracker.ietf.org/doc/html/rfc4648#section-8).
*/
Base16 = "base16",
/**
* Base 32 encoding using the alphabet `A-Z2-7`, as defined by
* [RFC 4648, Section 6](https://datatracker.ietf.org/doc/html/rfc4648#section-6).
*/
Base32 = "base32",
/**
* Base 32 encoding using the "Extended Hex" alphabet `0-9A-V`, as defined by
* [RFC 4648, Section 7](https://datatracker.ietf.org/doc/html/rfc4648#section-7).
*/
Base32Hex = "base32hex",
/**
* Base 64 encoding as defined by
* [RFC 4648, Section 4](https://datatracker.ietf.org/doc/html/rfc4648#section-4).
* Useful for data that is mostly non-text. Where RFC 2045 and RFC 4648
* differ, the RFC 4648 definition (no line length limit) SHOULD be assumed.
*/
Base64 = "base64",
/**
* Base 64 encoding with the URL and filename safe alphabet (`-` and `_`
* instead of `+` and `/`), as defined by
* [RFC 4648, Section 5](https://datatracker.ietf.org/doc/html/rfc4648#section-5).
*/
Base64URL = "base64url",
/**
* Same character set as 8bit, with no line length restriction.
*/
Binary = "binary",
/**
* An extension token defined by a standards-track RFC and registered with
* IANA.
*/
IETFToken = "ietf-token",
/**
* Lines are limited to 76 characters, and line breaks are represented using
* special characters that are escaped.
*/
QuotedPrintable = "quoted-printable",
/**
* The two characters "X-" or "x-" followed, with no intervening white space,
* by any token.
*/
XToken = "x-token"
}
/**
* This enum provides well-known formats that apply to strings.
*/
export declare enum Format {
/**
* A string instance is valid against this attribute if it is a valid
* representation according to the "full-date" ABNF rule in [RFC
* 3339][RFC3339].
*
* [RFC3339]: https://datatracker.ietf.org/doc/html/rfc3339
*/
Date = "date",
/**
* A string instance is valid against this attribute if it is a valid
* representation according to the "date-time" ABNF rule in [RFC
* 3339][RFC3339].
*
* [RFC3339]: https://datatracker.ietf.org/doc/html/rfc3339
*/
DateTime = "date-time",
/**
* A string instance is valid against this attribute if it is a valid
* representation according to the "duration" ABNF rule in [RFC
* 3339][RFC3339].
*
* [RFC3339]: https://datatracker.ietf.org/doc/html/rfc3339
*/
Duration = "duration",
/**
* A string instance is valid against this attribute if it is a valid Internet
* email address as defined by the "Mailbox" ABNF rule in [RFC 5321][RFC5321],
* section 4.1.2.
*
* [RFC5321]: https://datatracker.ietf.org/doc/html/rfc5321
*/
Email = "email",
/**
* As defined by [RFC 1123, section 2.1][RFC1123], including host names
* produced using the Punycode algorithm specified in [RFC 5891, section
* 4.4][RFC5891].
*
* [RFC1123]: https://datatracker.ietf.org/doc/html/rfc1123
* [RFC5891]: https://datatracker.ietf.org/doc/html/rfc5891
*/
Hostname = "hostname",
/**
* A string instance is valid against this attribute if it is a valid Internet
* email address as defined by the extended "Mailbox" ABNF rule in [RFC
* 6531][RFC6531], section 3.3.
*
* [RFC6531]: https://datatracker.ietf.org/doc/html/rfc6531
*/
IDNEmail = "idn-email",
/**
* As defined by either [RFC 1123, section 2.1][RFC1123] as for hostname, or
* an internationalized hostname as defined by [RFC 5890, section
* 2.3.2.3][RFC5890].
*
* [RFC1123]: https://datatracker.ietf.org/doc/html/rfc1123
* [RFC5890]: https://datatracker.ietf.org/doc/html/rfc5890
*/
IDNHostname = "idn-hostname",
/**
* An IPv4 address according to the "dotted-quad" ABNF syntax as defined in
* [RFC 2673, section 3.2][RFC2673].
*
* [RFC2673]: https://datatracker.ietf.org/doc/html/rfc2673
*/
IPv4 = "ipv4",
/**
* An IPv6 address as defined in [RFC 4291, section 2.2][RFC4291].
*
* [RFC4291]: https://datatracker.ietf.org/doc/html/rfc4291
*/
IPv6 = "ipv6",
/**
* A string instance is valid against this attribute if it is a valid IRI,
* according to [RFC 3987][RFC3987].
*
* [RFC3987]: https://datatracker.ietf.org/doc/html/rfc3987
*/
IRI = "iri",
/**
* A string instance is valid against this attribute if it is a valid IRI
* Reference (either an IRI or a relative-reference), according to [RFC
* 3987][RFC3987].
*
* [RFC3987]: https://datatracker.ietf.org/doc/html/rfc3987
*/
IRIReference = "iri-reference",
/**
* A string instance is valid against this attribute if it is a valid JSON
* string representation of a JSON Pointer, according to [RFC 6901, section
* 5][RFC6901].
*
* [RFC6901]: https://datatracker.ietf.org/doc/html/rfc6901
*/
JSONPointer = "json-pointer",
/**
* A string instance is valid against this attribute if it is a valid JSON
* string representation of a JSON Pointer fragment, according to [RFC 6901,
* section 5][RFC6901].
*
* [RFC6901]: https://datatracker.ietf.org/doc/html/rfc6901
*/
JSONPointerURIFragment = "json-pointer-uri-fragment",
/**
* This attribute applies to string instances.
*
* A regular expression, which SHOULD be valid according to the
* [ECMA-262][ecma262] regular expression dialect.
*
* Implementations that validate formats MUST accept at least the subset of
* [ECMA-262][ecma262] defined in the [Regular Expressions][regexInterop]
* section of this specification, and SHOULD accept all valid
* [ECMA-262][ecma262] expressions.
*
* [ecma262]:
* https://www.ecma-international.org/publications-and-standards/standards/ecma-262/
* [regexInterop]:
* https://json-schema.org/draft/2020-12/json-schema-validation.html#regexInterop
*/
RegEx = "regex",
/**
* A string instance is valid against this attribute if it is a valid
* [Relative JSON Pointer][relative-json-pointer].
*
* [relative-json-pointer]:
* https://datatracker.ietf.org/doc/html/draft-handrews-relative-json-pointer-01
*/
RelativeJSONPointer = "relative-json-pointer",
/**
* A string instance is valid against this attribute if it is a valid
* representation according to the "full-time" ABNF rule in [RFC
* 3339][RFC3339].
*
* [RFC3339]: https://datatracker.ietf.org/doc/html/rfc3339
*/
Time = "time",
/**
* A string instance is valid against this attribute if it is a valid URI,
* according to [RFC3986][RFC3986].
*
* [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
*/
URI = "uri",
/**
* A string instance is valid against this attribute if it is a valid URI
* Reference (either a URI or a relative-reference), according to
* [RFC3986][RFC3986].
*
* [RFC3986]: https://datatracker.ietf.org/doc/html/rfc3986
*/
URIReference = "uri-reference",
/**
* A string instance is valid against this attribute if it is a valid URI
* Template (of any level), according to [RFC 6570][RFC6570].
*
* Note that URI Templates may be used for IRIs; there is no separate IRI
* Template specification.
*
* [RFC6570]: https://datatracker.ietf.org/doc/html/rfc6570
*/
URITemplate = "uri-template",
/**
* A string instance is valid against this attribute if it is a valid string
* representation of a UUID, according to [RFC 4122][RFC4122].
*
* [RFC4122]: https://datatracker.ietf.org/doc/html/rfc4122
*/
UUID = "uuid"
}
/**
* Enum consisting of simple type names for the `type` keyword
*/
export declare enum TypeName {
/**
* Value MUST be an array.
*/
Array = "array",
/**
* Value MUST be a boolean.
*/
Boolean = "boolean",
/**
* Value MUST be an integer, no floating point numbers are allowed. This is a
* subset of the number type.
*/
Integer = "integer",
/**
* Value MUST be null. Note this is mainly for purpose of being able use union
* types to define nullability. If this type is not included in a union, null
* values are not allowed (the primitives listed above do not allow nulls on
* their own).
*/
Null = "null",
/**
* Value MUST be a number, floating point numbers are allowed.
*/
Number = "number",
/**
* Value MUST be an object.
*/
Object = "object",
/**
* Value MUST be a string.
*/
String = "string"
}
export declare const keywords: readonly ["$anchor", "$comment", "$defs", "$dynamicAnchor", "$dynamicRef", "$id", "$recursiveAnchor", "$recursiveRef", "$ref", "$schema", "$vocabulary", "additionalItems", "additionalProperties", "allOf", "anyOf", "const", "contains", "contentEncoding", "contentMediaType", "contentSchema", "default", "definitions", "dependencies", "dependentRequired", "dependentSchemas", "deprecated", "description", "else", "enum", "examples", "exclusiveMaximum", "exclusiveMinimum", "format", "if", "items", "maxContains", "maximum", "maxItems", "maxLength", "maxProperties", "minContains", "minimum", "minItems", "minLength", "minProperties", "multipleOf", "not", "oneOf", "pattern", "patternProperties", "prefixItems", "properties", "propertyNames", "readOnly", "required", "then", "title", "type", "unevaluatedItems", "unevaluatedProperties", "uniqueItems", "writeOnly"];
export {};