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