json-schema-typed
Version:
JSON Schema TypeScript definitions with complete inline documentation.
1,326 lines (1,235 loc) • 56.2 kB
text/typescript
// @generated
// This code is automatically generated. Manual editing is not recommended.
/*
* BSD-2-Clause License
*
* Original source code is copyright (c) 2022 Jeremy Rylan
* <https://github.com/jrylan>
*
* Documentation and keyword descriptions are copyright (c) 2019 IETF Trust
* <https://www.ietf.org/>, Austin Wright <aaa@bzfx.net>, Henry Andrews
* <andrews_henry@yahoo.com>, Ben Hutton <bh7@sanger.ac.uk>, and Greg Dennis
* <gregsdennis@yahoo.com>. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
export const draft = "2019-09" as const;
export const $schema = "https://json-schema.org/draft/2019-09/schema" as const;
type MaybeReadonlyArray<T> = Array<T> | ReadonlyArray<T>;
type ValueOf<T> = T[keyof T];
/**
* JSON Schema [Draft 2019-09](https://json-schema.org/draft/2019-09/json-schema-validation.html)
*/
export type JSONSchema<
Value = any,
SchemaType = 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,
> = boolean | {
/**
* 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 SHOULD treat `$comment` identically to an unknown
* extension keyword. They 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` keywords provides a standardized 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, JSONSchema>;
/**
* 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). Therefore, `$id` MUST NOT contain a non-empty fragment,
* and SHOULD NOT contain an empty fragment.
*
* Since an empty fragment in the context of the
* `application/schema+json` media type refers to the same resource as
* the base URI without a fragment, an implementation MAY normalize a URI
* ending with an empty fragment by removing the fragment. However, schema
* authors SHOULD NOT rely on this behavior across implementations.
*
* This 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;
/**
* The value of the `$recursiveAnchor` property MUST be a boolean.
*
* `$recursiveAnchor` is used to dynamically identify a base URI at
* runtime for `$recursiveRef` by marking where such a calculation can
* start, and where it stops. This keyword MUST NOT affect the base URI of
* other keywords, unless they are explicitly defined to rely on it.
*
* If set to `true`, then when the containing schema object is used as a
* target of `$recursiveRef`, a new base URI is determined by examining
* the [dynamic scope][scopes] for the outermost schema that also contains
* `$recursiveAnchor` with a value of `true`. The base URI of that
* schema is then used as the dynamic base URI.
*
* - If no such schema exists, then the base URI is unchanged.
* - If this keyword is set to `false`, the base URI is unchanged.
*
* Omitting this keyword has the same behavior as a value of `false`.
*
* [scopes]: https://json-schema.org/draft/2019-09/json-schema-core.html#scopes
*/
$recursiveAnchor?: boolean;
/**
* The value of the `$recursiveRef` property MUST be a string which is
* a URI-reference. It is a by-reference applicator that uses a
* dynamically calculated base URI to resolve its value.
*
* The behavior of this keyword is defined only for the value `"#"`.
* Implementations MAY choose to consider other values to be errors.
*
* The value of `$recursiveRef` is initially resolved against the
* current base URI, in the same manner as for `$ref`.
*
* The schema identified by the resulting URI is examined for the
* presence of `$recursiveAnchor`, and a new base URI is calculated.
*
* Finally, the value of `$recursiveRef` is resolved against the new base
* URI determined according to `$recursiveAnchor` producing the final
* resolved reference URI.
*
* Note that in the absence of `$recursiveAnchor` (and in some cases
* when it is present), `$recursiveRef`'s behavior is identical to
* that of `$ref`.
*
* As with `$ref`, the results of this keyword are the results of the
* referenced schema.
*
* @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 version identifier
* and the location of a resource which is itself a JSON Schema, which
* describes any schema written for this particular version.
*
* 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 a resource root schema.
* It MUST NOT appear in resource subschemas. If absent from the root
* schema, the resulting behavior is implementation-defined.
*
* If multiple schema resources are present in a single document, then all
* schema resources SHOULD Have the same value for `$schema`. The result
* of differing values for "$schema" within the same schema document 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.
*
* 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.
*
* 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, string>;
/**
* The value of `additionalItems` MUST be a valid JSON Schema.
*
* The behavior of this keyword depends on the presence and annotation
* result of `items` within the same schema object.
* If `items` is present, and its annotation result is a number,
* validation succeeds if every instance element at an index greater than
* that number validates against `additionalItems`.
*
* Otherwise, if `items` is absent or its annotation result is the
* boolean `true`, `additionalItems` MUST be ignored.
*
* If the `additionalItems` subschema is applied to any positions within
* the instance array, it produces an annotation result of boolean
* `true`, analogous to the single schema behavior of `items`. If any
* `additionalItems` keyword from any subschema applied to the same
* instance location produces an annotation value of `true`, then the
* combined result from these keywords is also `true`.
*
* 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 an `items` array.
*/
additionalItems?: JSONSchema;
/**
* 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.
*
* 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?: JSONSchema;
/**
* 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<JSONSchema<Value, SchemaType>>;
/**
* 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<JSONSchema<Value, SchemaType>>;
/**
* 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;
/**
* An array instance is valid against `contains` if at least one of
* its elements is valid against the given schema. Note that when
* collecting annotations, the subschema MUST be applied to every
* array element even after the first match has been found. This
* is to ensure that all possible annotations are collected.
*/
contains?: JSONSchema<Value, SchemaType>;
/**
* If the instance value is a string, this property defines that the
* string SHOULD be interpreted as binary data and decoded using the
* encoding named by this property. [RFC 2045, Sec 6.1][RFC2045] lists the
* possible values for this property.
*
* The value of this property SHOULD be ignored if the instance described
* is not a string.
*
* If this keyword is absent, but `contentMediaType` is present, this
* indicates that the media type could be encoded into `UTF-8` like any
* other JSON string value, and does not require additional decoding.
*
* The value of this property MUST be a string.
*
* [RFC2045]: https://datatracker.ietf.org/doc/html/rfc2045#section-6.1
*/
contentEncoding?:
| "7bit"
| "8bit"
| "base64"
| "binary"
| "ietf-token"
| "quoted-printable"
| "x-token";
/**
* 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 SHOULD be ignored if `contentMediaType` is
* not present.
*/
contentSchema?: JSONSchema<Value, SchemaType>;
/**
* 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, JSONSchema>;
/**
* @deprecated `dependencies` has been split into two keywords:
* `dependentSchemas` and `dependentRequired`.
*/
dependencies?: Record<string, MaybeReadonlyArray<string> | JSONSchema>;
/**
* 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, JSONSchema>;
/**
* 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.
*
* When the `deprecated` keyword is applied to an item in an array by
* means of `items`, if `items` is a single schema, the deprecation
* relates to the whole array, while if `items` is an array of schemas,
* the deprecation relates to the corresponding item according to the
* subschemas position.
*
* Omitting this keyword has the same behavior as a value of `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?: JSONSchema<Value, SchemaType>;
/**
* 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?: JSONSchema<Value, SchemaType>;
/**
* The value of `items` MUST be either a valid JSON Schema or an array of
* valid JSON Schemas.
*
* If `items` is a schema, validation succeeds if all elements in the
* array successfully validate against that schema.
*
* If `items` is an array of schemas, validation succeeds if each element
* of the instance validates against the schema at the same position, if
* any.
*
* 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 when `items` is a schema.
*
* Annotation results for `items` keywords from multiple schemas applied
* to the same instance location are combined by setting the combined
* result to `true` if any of the values are `true`, and otherwise
* retaining the largest numerical value.
*
* Omitting this keyword has the same assertion behavior as an empty
* schema.
*/
items?: MaybeReadonlyArray<JSONSchema> | JSONSchema;
/**
* The value of this keyword MUST be a non-negative integer.
*
* An array instance is valid against `maxContains` if the number of
* elements that are valid against the schema for
* `contains` is less than, or equal to, the value of this keyword.
*
* If `contains` is not present within the same schema object, then this
* keyword has no effect.
*/
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.
*
* An array instance is valid against `minContains` if the number of
* elements that are valid against the schema for `contains` is
* greater than, or equal to, the value of this keyword.
*
* 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` with no `maxContains` causes `contains` to always pass
* validation.
*
* If `contains` is not present within the same schema object, then this
* keyword has no effect.
*
* Omitting this keyword has the same behavior as a value of `1`.
*
* @default 1
*/
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?: JSONSchema<Value, SchemaType>;
/**
* 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<JSONSchema<Value, SchemaType>>;
/**
* 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. Annotation results for
* `patternProperties` keywords from multiple schemas applied to the same
* instance location are combined by taking the union of the sets.
*
* 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, JSONSchema>;
/**
* 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. Annotation results for `properties`
* keywords from multiple schemas applied to the same instance location are
* combined by taking the union of the sets.
*
* Omitting this keyword has the same assertion behavior as an empty
* object.
*/
properties?: Record<string, JSONSchema>;
/**
* 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?: JSONSchema;
/**
* 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?: JSONSchema<Value, SchemaType>;
/**
* 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.
*
* An instance validates if and only if the instance is in any of the sets
* listed for this keyword.
*/
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 `items` and `additionalItems`,
* which can come from those keywords when they are adjacent to the
* `unevaluatedItems` keyword. Those two annotations, as well as
* `unevaluatedItems`, can also result from any and all adjacent
* [in-place applicator][in-place-applicator] keywords.
*
* If an `items` annotation is present, and its annotation result is a
* number, and no "additionalItems" or `unevaluatedItems` annotation is
* present, then validation succeeds if every instance element at an index
* greater than the `items` annotation validates against
* `unevaluatedItems`.
*
* Otherwise, if any `items`, `additionalItems`, or
* `unevaluatedItems` annotations are present with a value of boolean
* `true`, then `unevaluatedItems` MUST be ignored. However, if none
* of these annotations are present, `unevaluatedItems` MUST be applied
* to all locations in the array.
*
* This means that `items`, `additionalItems`, 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 before 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 single schema behavior of `items`. If any
* `unevaluatedItems` keyword from any subschema applied to the same
* instance location produces an annotation value of `true`, then the
* combined result from these keywords is also `true`.
*
* Omitting this keyword has the same assertion behavior as an empty
* schema.
*
* Implementations that do not collect annotations MUST raise an error
* upon encountering this keyword.
*
* [in-place-applicator]: https://json-schema.org/draft/2019-09/json-schema-core.html#in-place
*/
unevaluatedItems?: JSONSchema;
/**
* 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
* before this keyword.
*
* The annotation result of this keyword is the set of instance property
* names validated by this keyword's subschema. Annotation results for
* `unevaluatedProperties` keywords from multiple schemas applied to the
* same instance location are combined by taking the union of the sets.
*
* Omitting this keyword has the same assertion behavior as an empty
* schema.
*
* Implementations that do not collect annotations MUST raise an error upon
* encountering this keyword.
*
* [in-place-applicator]: https://json-schema.org/draft/2019-09/json-schema-core.html#in-place
*/
unevaluatedProperties?: JSONSchema;
/**
* 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;
};
// -----------------------------------------------------------------------------
export namespace JSONSchema {
export type TypeValue = (
| ValueOf<TypeName>
| TypeName
| Array<ValueOf<TypeName> | TypeName>
| ReadonlyArray<ValueOf<TypeName> | TypeName>
);
/**
* JSON Schema interface
*/
export type Interface<
Value = any,
SchemaType extends TypeValue = TypeValue,
> = Exclude<
JSONSchema<Value, SchemaType>,
boolean
>;
export type Array<T = any> = Pick<
Interface<T, "array">,
KeywordByType.Any | KeywordByType.Array
>;
export type Boolean = Pick<
Interface<boolean, "boolean">,
KeywordByType.Any
>;
export type Integer = Pick<
Interface<number, "integer">,
KeywordByType.Any | KeywordByType.Number
>;
export type Number = Pick<
Interface<number, "number">,
KeywordByType.Any | KeywordByType.Number
>;
export type Null = Pick<
Interface<null, "null">,
KeywordByType.Any
>;
export type Object<T = any> = Pick<
Interface<T, "object">,
KeywordByType.Any | KeywordByType.Object
>;
export type String = Pick<
Interface<string, "string">,
KeywordByType.Any | KeywordByType.String
>;
}
namespace KeywordByType {
export type Any =
| "$anchor"
| "$comment"
| "$defs"
| "$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";
export type Array =
| "additionalItems"
| "contains"
| "items"
| "maxContains"
| "maxItems"
| "minContains"
| "minItems"
| "unevaluatedItems"
| "uniqueItems";
export type Number =
| "exclusiveMaximum"
| "exclusiveMinimum"
| "maximum"
| "minimum"
| "multipleOf";
export type Object =
| "additionalProperties"
| "dependencies"
| "dependentRequired"
| "dependentSchemas"
| "maxProperties"
| "minProperties"
| "patternProperties"
| "properties"
| "propertyNames"
| "required"
| "unevaluatedProperties";
export type String =
| "contentEncoding"
| "contentMediaType"
| "contentSchema"
| "maxLength"
| "minLength"
| "pattern";
}
// -----------------------------------------------------------------------------
/**
* Content encoding strategy enum.
*
* - [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 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",
/**
* Useful for data that is mostly non-text.
*/
Base64 = "base64",
/**
* 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 enum Format {
/**
* A string instance is valid against this attribute if it is a valid
* representation according to the "full-date" production 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" production 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" production.
*/
Duration = "duration",
/**
* A string instance is valid against this attribute if it is a valid Internet
* email address as defined by [RFC 5322, section 3.4.1][RFC5322].
*
* [RFC5322]: https://datatracker.ietf.org/doc/html/rfc5322
*/
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 [RFC 6531][RFC6531].
*
* [RFC6531