mcp-use 2.0.0-beta.4 → 2.0.0-beta.41

package/node_modules/@modelcontextprotocol/client/dist/types-BDNQEPSs.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-BDNQEPSs.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<T> = Array<T> | ReadonlyArray<T>;\r\ntype ValueOf<T> = 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<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 | {\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<string, JSONSchema>;\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<string, string>;\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<JSONSchema<Value, SchemaType>>;\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<JSONSchema<Value, SchemaType>>;\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<Value, SchemaType>;\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<Value, SchemaType>;\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<string, JSONSchema>;\r\n    /**\r\n     * @deprecated `dependencies` has been split into two keywords:\r\n     * `dependentSchemas` and `dependentRequired`.\r\n     */\r\n    dependencies?: Record<string, MaybeReadonlyArray<string> | 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<string, MaybeReadonlyArray<string>>;\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<string, 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, 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<Value, SchemaType>;\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<Value>;\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<Value>;\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<Value, SchemaType>;\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<Value, SchemaType>;\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<JSONSchema<Value, SchemaType>>;\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<string, JSONSchema>;\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> | 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<string, JSONSchema>;\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<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 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<Value, SchemaType>;\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> | TypeName | Array<ValueOf<TypeName> | TypeName> | ReadonlyArray<ValueOf<TypeName> | TypeName>;\r\n    /**\r\n     * JSON Schema interface\r\n     */\r\n    type Interface<Value = any, SchemaType extends TypeValue = TypeValue> = Exclude<JSONSchema<Value, SchemaType>, boolean>;\r\n    type Array<T = any> = Pick<Interface<T, \"array\">, KeywordByType.Any | KeywordByType.Array>;\r\n    type Boolean = Pick<Interface<boolean, \"boolean\">, KeywordByType.Any>;\r\n    type Integer = Pick<Interface<number, \"integer\">, KeywordByType.Any | KeywordByType.Number>;\r\n    type Number = Pick<Interface<number, \"number\">, KeywordByType.Any | KeywordByType.Number>;\r\n    type Null = Pick<Interface<null, \"null\">, KeywordByType.Any>;\r\n    type Object<T = any> = Pick<Interface<T, \"object\">, KeywordByType.Any | KeywordByType.Object>;\r\n    type String = Pick<Interface<string, \"string\">, 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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"}