@orpc/interop 0.0.0-next.0021fba

package/dist/json-schema-typed/draft-2019-09.d.mts

@@ -0,0 +1,1248 @@
+declare const draft: "2019-09";
+declare const $schema: "https://json-schema.org/draft/2019-09/schema";
+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)
+ */
+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;
+};
+declare namespace JSONSchema {
+    type TypeValue = (ValueOf<TypeName> | TypeName | Array<ValueOf<TypeName> | TypeName> | ReadonlyArray<ValueOf<TypeName> | TypeName>);
+    /**
+     * JSON Schema interface
+     */
+    type Interface<Value = any, SchemaType extends TypeValue = TypeValue> = Exclude<JSONSchema<Value, SchemaType>, boolean>;
+    type Array<T = any> = Pick<Interface<T, "array">, KeywordByType.Any | KeywordByType.Array>;
+    type Boolean = Pick<Interface<boolean, "boolean">, KeywordByType.Any>;
+    type Integer = Pick<Interface<number, "integer">, KeywordByType.Any | KeywordByType.Number>;
+    type Number = Pick<Interface<number, "number">, KeywordByType.Any | KeywordByType.Number>;
+    type Null = Pick<Interface<null, "null">, KeywordByType.Any>;
+    type Object<T = any> = Pick<Interface<T, "object">, KeywordByType.Any | KeywordByType.Object>;
+    type String = Pick<Interface<string, "string">, KeywordByType.Any | KeywordByType.String>;
+}
+declare namespace KeywordByType {
+    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";
+    type Array = "additionalItems" | "contains" | "items" | "maxContains" | "maxItems" | "minContains" | "minItems" | "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.
+ *
+ * - [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)
+ */
+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",
+    /**
+     * 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.
+ */
+declare 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]: 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/2019-09/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 "time" production 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
+ */
+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"
+}
+declare const keywords: readonly ["$anchor", "$comment", "$defs", "$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", "properties", "propertyNames", "readOnly", "required", "then", "title", "type", "unevaluatedItems", "unevaluatedProperties", "uniqueItems", "writeOnly"];
+
+export { $schema, ContentEncoding, Format, JSONSchema, TypeName, draft, keywords };