ostacky 0.5.5 → 0.5.7

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/types-mS0yxCL0.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-mS0yxCL0.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":";;KAEKE,kBAA8BC,CAAAA,CAAAA,CAAAA,GAANC,KAAMD,CAAAA,CAAAA,CAAAA,GAAKE,aAALF,CAAmBA,CAAnBA,CAAAA;KAC9BG,OADwBF,CAAAA,CAAAA,CAAAA,GACXD,CADWC,CAAAA,MACHD,CADGC,CAAAA;;;;AACxBE,KAIOC,UAJAJ,CAAAA,QAAcA,GAAC,EAAA,cAIsBK,KAJtB,SAAA,OAAA,GAAA,SAAA,GAI0DA,KAJ1D,SAAA,IAAA,GAAA,MAAA,GAIwFA,KAJxF,SAAA,MAAA,GAAA,QAAA,GAAA,SAAA,GAIsIA,KAJtI,SAAA,MAAA,GAAA,QAAA,GAIwKA,KAJxK,SAAA,OAAA,EAAA,GAAA,OAAA,GAI4MA,KAJ5M,SAI0NE,MAJ1N,CAAA,MAAA,GAAA,MAAA,EAAA,OAAA,CAAA,GAAA,QAAA,GAIwQH,UAAAA,CAAWI,SAJnR,EAAA,GAAA,OAAA,GAAA;EAIfJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2WQA,OAAAA,CAAAA,EAAAA,MAAAA;EAMNC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyYuBD,QAAAA,CAAAA,EAAAA,MAAAA;EAAnBL;;;;;;;;EAyEPK,KAAAA,CAAAA,EA9vBCG,MA8vBDH,CAAAA,MAAAA,EA9vBgBA,UA8vBhBA,CAAAA;EAkBAE;;;;AA8GX;;;EACyCG,cAAAA,CAAAA,EAAAA,MAAAA;EAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS7CE,WAAAA,CAAAA,EAAAA,MAAAA;EAAyBC;;;;;;;;;;;;AAG7C;AA4ND;;;;ACtqCA;AAKA;AAOA;AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBDgMkBL;;;;;oBAKIH;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0BKA;;;;;;;;UAQfL,mBAAmBK,WAAWC,OAAOC;;;;;;;;;UASrCP,mBAAmBK,WAAWC,OAAOC;;;;;;;;UAQrCD;;;;;;;;;;;;;;;;;;;;;aAqBGD,WAAWC,OAAOC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDbF,WAAWC,OAAOC;;;;;;YAMxBD;;;;gBAIIE,eAAeH;;;;;iBAKdG,eAAeR,6BAA6BK;;;;;;;;;;;;;;;;;sBAiBvCG,eAAeR;;;;;;;;;;;;;;qBAchBQ,eAAeH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAwC3BA,WAAWC,OAAOC;;;;;;;;;;SAUlBP,mBAAmBM;;;;;;;;;;;;;;aAcfN,mBAAmBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDzBD,WAAWC,OAAOC;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BfF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiJFA,WAAWC,OAAOC;;;;;;;;UAQhBP,mBAAmBK,WAAWC,OAAOC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAgCzBC,eAAeH;;;;;;;;;;;;;;;;;;;;gBAoBrBL,mBAAmBK,cAAcA;;;;;;;;;;;;;;;eAelCG,eAAeH;;;;;;;;;;;kBAWZA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkCLL;;;;;;;;;;;;;SAaJK,WAAWC,OAAOC;;;;;;;;;;;;;;;;;;SAkBlBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCYF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAoCKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwCHA,UAAAA;mBACJD,QAAQM,YAAYA,WAAWR,MAAME,QAAQM,YAAYA,YAAYP,cAAcC,QAAQM,YAAYA;;;;iDAIzED,YAAYA,aAAaE,QAAQN,WAAWC,OAAOC;wBAC5EQ,KAAKH,UAAUX,aAAaY,aAAAA,CAAcC,MAAMD,aAAAA,CAAcX;iBACrEa,KAAKH,+BAA+BC,aAAAA,CAAcC;iBAClDC,KAAKH,8BAA8BC,aAAAA,CAAcC,MAAMD,aAAAA,CAAcG;gBACtED,KAAKH,6BAA6BC,aAAAA,CAAcC,MAAMD,aAAAA,CAAcG;cACtED,KAAKH,yBAAyBC,aAAAA,CAAcC;yBACjCC,KAAKH,UAAUX,cAAcY,aAAAA,CAAcC,MAAMD,aAAAA,CAAcI;gBACxEF,KAAKH,6BAA6BC,aAAAA,CAAcC,MAAMD,aAAAA,CAAcK;;kBAEpEL,aAAAA;;;;;;;;;;;;;;;;;aA2NEH,QAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAlrCyD;;;;;;AACxB;AAKrD;;;AAAmHJ,KCMvG,cAAA,GAAiB,UAAA,CAAW,SDN2EA;;;;AAAkIE,KCWzO,yBDXyOA,CAAAA,CAAAA,CAAAA,GAAAA;EAA8CH,KAAAA,EAAAA,IAAWI;EAqEnRJ,IAAAA,ECzDA,CDyDAA;EAAfG,YAAAA,EAAAA,SAAAA;CAsKMA,GAAAA;EAKIH,KAAAA,EAAAA,KAAAA;EA0BKA,IAAAA,EAAAA,SAAAA;EAQeC,YAAAA,EAAAA,MAAAA;CAAOC;;;;AASAA,KCzQrC,mBDyQqCA,CAAAA,CAAAA,CAAAA,GAAAA,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,GCzQQ,yBDyQRA,CCzQkC,CDyQlCA,CAAAA;;;;;;;;;;;;;;;;;;;;;;;;AAgLtCP,UChaM,mBAAA,CDgaNA;EAcuBM;;;;;;EAqObA,YAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EC5oBO,cD4oBPA,CAAAA,EC5oBwB,mBD4oBxBA,CC5oB4C,CD4oB5CA,CAAAA"}

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/ajv.cjs

@@ -1,5 +0,0 @@
-const require_ajvProvider = require('../ajvProvider-Brn-Q2J_.cjs');
-
-exports.Ajv = require_ajvProvider.Ajv;
-exports.AjvJsonSchemaValidator = require_ajvProvider.AjvJsonSchemaValidator;
-exports.addFormats = require_ajvProvider.addFormats;

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/ajv.d.cts

@@ -1,2 +0,0 @@
-import { n as AjvJsonSchemaValidator, r as addFormats, t as Ajv } from "../ajvProvider-B_4czhCS.cjs";
-export { Ajv, AjvJsonSchemaValidator, addFormats };

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/ajv.d.mts

@@ -1,2 +0,0 @@
-import { n as AjvJsonSchemaValidator, r as addFormats, t as Ajv } from "../ajvProvider-BdSo9BII.mjs";
-export { Ajv, AjvJsonSchemaValidator, addFormats };

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/ajv.mjs

@@ -1,3 +0,0 @@
-import { n as AjvJsonSchemaValidator, r as addFormats, t as Ajv } from "../ajvProvider-CplOkyLC.mjs";
-
-export { Ajv, AjvJsonSchemaValidator, addFormats };

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/cfWorker.cjs

@@ -1,3 +0,0 @@
-const require_cfWorkerProvider = require('../cfWorkerProvider-ojcZaap3.cjs');
-
-exports.CfWorkerJsonSchemaValidator = require_cfWorkerProvider.CfWorkerJsonSchemaValidator;

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/cfWorker.d.cts

@@ -1,2 +0,0 @@
-import { n as CfWorkerSchemaDraft, t as CfWorkerJsonSchemaValidator } from "../cfWorkerProvider-D9GAttn8.cjs";
-export { CfWorkerJsonSchemaValidator, type CfWorkerSchemaDraft };

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/cfWorker.d.mts

@@ -1,2 +0,0 @@
-import { n as CfWorkerSchemaDraft, t as CfWorkerJsonSchemaValidator } from "../cfWorkerProvider-BYRW5af5.mjs";
-export { CfWorkerJsonSchemaValidator, type CfWorkerSchemaDraft };

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/dist/validators/cfWorker.mjs

@@ -1,3 +0,0 @@
-import { t as CfWorkerJsonSchemaValidator } from "../cfWorkerProvider-Bd-iTHAF.mjs";
-
-export { CfWorkerJsonSchemaValidator };

package/assets/mcp/ask-user-server/node_modules/@modelcontextprotocol/server/package.json

@@ -1,160 +0,0 @@
-{
-  "name": "@modelcontextprotocol/server",
-  "version": "2.0.0-beta.4",
-  "description": "Model Context Protocol implementation for TypeScript - Server package",
-  "license": "MIT",
-  "author": "Anthropic, PBC (https://anthropic.com)",
-  "homepage": "https://modelcontextprotocol.io",
-  "bugs": "https://github.com/modelcontextprotocol/typescript-sdk/issues",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/modelcontextprotocol/typescript-sdk.git"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "keywords": [
-    "modelcontextprotocol",
-    "mcp",
-    "server"
-  ],
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    },
-    "./stdio": {
-      "import": {
-        "types": "./dist/stdio.d.mts",
-        "default": "./dist/stdio.mjs"
-      },
-      "require": {
-        "types": "./dist/stdio.d.cts",
-        "default": "./dist/stdio.cjs"
-      }
-    },
-    "./validators/ajv": {
-      "import": {
-        "types": "./dist/validators/ajv.d.mts",
-        "default": "./dist/validators/ajv.mjs"
-      },
-      "require": {
-        "types": "./dist/validators/ajv.d.cts",
-        "default": "./dist/validators/ajv.cjs"
-      }
-    },
-    "./validators/cf-worker": {
-      "import": {
-        "types": "./dist/validators/cfWorker.d.mts",
-        "default": "./dist/validators/cfWorker.mjs"
-      },
-      "require": {
-        "types": "./dist/validators/cfWorker.d.cts",
-        "default": "./dist/validators/cfWorker.cjs"
-      }
-    },
-    "./_shims": {
-      "workerd": {
-        "import": {
-          "types": "./dist/shimsWorkerd.d.mts",
-          "default": "./dist/shimsWorkerd.mjs"
-        },
-        "require": {
-          "types": "./dist/shimsWorkerd.d.cts",
-          "default": "./dist/shimsWorkerd.cjs"
-        }
-      },
-      "browser": {
-        "import": {
-          "types": "./dist/shimsBrowser.d.mts",
-          "default": "./dist/shimsBrowser.mjs"
-        },
-        "require": {
-          "types": "./dist/shimsBrowser.d.cts",
-          "default": "./dist/shimsBrowser.cjs"
-        }
-      },
-      "node": {
-        "import": {
-          "types": "./dist/shimsNode.d.mts",
-          "default": "./dist/shimsNode.mjs"
-        },
-        "require": {
-          "types": "./dist/shimsNode.d.cts",
-          "default": "./dist/shimsNode.cjs"
-        }
-      },
-      "default": {
-        "import": {
-          "types": "./dist/shimsNode.d.mts",
-          "default": "./dist/shimsNode.mjs"
-        },
-        "require": {
-          "types": "./dist/shimsNode.d.cts",
-          "default": "./dist/shimsNode.cjs"
-        }
-      }
-    }
-  },
-  "main": "./dist/index.cjs",
-  "types": "./dist/index.d.mts",
-  "typesVersions": {
-    "*": {
-      "validators/ajv": [
-        "dist/validators/ajv.d.mts"
-      ],
-      "validators/cf-worker": [
-        "dist/validators/cfWorker.d.mts"
-      ],
-      "stdio": [
-        "dist/stdio.d.mts"
-      ]
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "zod": "^4.2.0",
-    "@modelcontextprotocol/core": "2.0.0-beta.4"
-  },
-  "devDependencies": {
-    "@cfworker/json-schema": "^4.1.1",
-    "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1",
-    "@eslint/js": "^9.39.2",
-    "@types/eventsource": "^1.1.15",
-    "@typescript/native-preview": "^7.0.0-dev.20251217.1",
-    "eslint": "^9.39.2",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-n": "^17.23.1",
-    "prettier": "3.6.2",
-    "supertest": "^7.0.0",
-    "tsdown": "^0.18.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.48.1",
-    "vitest": "^4.0.15",
-    "@modelcontextprotocol/eslint-config": "^2.0.0",
-    "@modelcontextprotocol/test-helpers": "^2.0.0-beta.0",
-    "@modelcontextprotocol/core-internal": "^2.0.0-beta.3",
-    "@modelcontextprotocol/tsconfig": "^2.0.0",
-    "@modelcontextprotocol/vitest-config": "^2.0.0"
-  },
-  "scripts": {
-    "typecheck": "tsgo -p tsconfig.json --noEmit",
-    "build": "tsdown",
-    "build:watch": "tsdown --watch",
-    "lint": "eslint src/ && prettier --ignore-path ../../.prettierignore --check .",
-    "lint:fix": "eslint src/ --fix && prettier --ignore-path ../../.prettierignore --write .",
-    "check": "pnpm run typecheck && pnpm run lint",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  }
-}

package/assets/mcp/ask-user-server/node_modules/zod/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Colin McDonnell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/assets/mcp/ask-user-server/node_modules/zod/README.md

@@ -1,191 +0,0 @@
-<p align="center">
-  <img src="logo.svg" width="200px" align="center" alt="Zod logo" />
-  <h1 align="center">Zod</h1>
-  <p align="center">
-    TypeScript-first schema validation with static type inference
-    <br/>
-    by <a href="https://x.com/colinhacks">@colinhacks</a>
-  </p>
-</p>
-<br/>
-
-<p align="center">
-<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amain"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Zod CI status" /></a>
-<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
-<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
-<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
-<a href="https://github.com/colinhacks/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
-</p>
-
-<div align="center">
-  <a href="https://zod.dev/api">Docs</a>
-  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
-  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://twitter.com/colinhacks">𝕏</a>
-  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://bsky.app/profile/zod.dev">Bluesky</a>
-  <br />
-</div>
-
-<br/>
-<br/>
-
-### [Read the docs →](https://zod.dev/api)
-
-<br/>
-<br/>
-
-## What is Zod?
-
-Zod is a TypeScript-first validation library. Define a schema and parse some data with it. You'll get back a strongly typed, validated result.
-
-```ts
-import * as z from "zod";
-
-const User = z.object({
-  name: z.string(),
-});
-
-// some untrusted data...
-const input = {
-  /* stuff */
-};
-
-// the parsed result is validated and type safe!
-const data = User.parse(input);
-
-// so you can use it with confidence :)
-console.log(data.name);
-```
-
-<br/>
-
-## Features
-
-- Zero external dependencies
-- Works in Node.js and all modern browsers
-- Tiny: `2kb` core bundle (gzipped)
-- Immutable API: methods return a new instance
-- Concise interface
-- Works with TypeScript and plain JS
-- Built-in JSON Schema conversion
-- Extensive ecosystem
-
-<br/>
-
-## Installation
-
-```sh
-npm install zod
-```
-
-<br/>
-
-## Basic usage
-
-Before you can do anything else, you need to define a schema. For the purposes of this guide, we'll use a simple object schema.
-
-```ts
-import * as z from "zod";
-
-const Player = z.object({
-  username: z.string(),
-  xp: z.number(),
-});
-```
-
-### Parsing data
-
-Given any Zod schema, use `.parse` to validate an input. If it's valid, Zod returns a strongly-typed _deep clone_ of the input.
-
-```ts
-Player.parse({ username: "billie", xp: 100 });
-// => returns { username: "billie", xp: 100 }
-```
-
-**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](https://zod.dev/api#refinements) or [transforms](https://zod.dev/api#transforms), you'll need to use the `.parseAsync()` method instead.
-
-```ts
-const schema = z.string().refine(async (val) => val.length <= 8);
-
-await schema.parseAsync("hello");
-// => "hello"
-```
-
-### Handling errors
-
-When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.
-
-```ts
-try {
-  Player.parse({ username: 42, xp: "100" });
-} catch (err) {
-  if (err instanceof z.ZodError) {
-    err.issues;
-    /* [
-      {
-        expected: 'string',
-        code: 'invalid_type',
-        path: [ 'username' ],
-        message: 'Invalid input: expected string'
-      },
-      {
-        expected: 'number',
-        code: 'invalid_type',
-        path: [ 'xp' ],
-        message: 'Invalid input: expected number'
-      }
-    ] */
-  }
-}
-```
-
-To avoid a `try/catch` block, you can use the `.safeParse()` method to get back a plain result object containing either the successfully parsed data or a `ZodError`. The result type is a [discriminated union](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions), so you can handle both cases conveniently.
-
-```ts
-const result = Player.safeParse({ username: 42, xp: "100" });
-if (!result.success) {
-  result.error; // ZodError instance
-} else {
-  result.data; // { username: string; xp: number }
-}
-```
-
-**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](https://zod.dev/api#refinements) or [transforms](https://zod.dev/api#transforms), you'll need to use the `.safeParseAsync()` method instead.
-
-```ts
-const schema = z.string().refine(async (val) => val.length <= 8);
-
-await schema.safeParseAsync("hello");
-// => { success: true; data: "hello" }
-```
-
-### Inferring types
-
-Zod infers a static type from your schema definitions. You can extract this type with the `z.infer<>` utility and use it however you like.
-
-```ts
-const Player = z.object({
-  username: z.string(),
-  xp: z.number(),
-});
-
-// extract the inferred type
-type Player = z.infer<typeof Player>;
-
-// use it in your code
-const player: Player = { username: "billie", xp: 100 };
-```
-
-In some cases, the input & output types of a schema can diverge. For instance, the `.transform()` API can convert the input from one type to another. In these cases, you can extract the input and output types independently:
-
-```ts
-const mySchema = z.string().transform((val) => val.length);
-
-type MySchemaIn = z.input<typeof mySchema>;
-// => string
-
-type MySchemaOut = z.output<typeof mySchema>; // equivalent to z.infer<typeof mySchema>
-// number
-```

package/assets/mcp/ask-user-server/node_modules/zod/index.cjs

@@ -1,33 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.z = void 0;
-const z = __importStar(require("./v4/classic/external.cjs"));
-exports.z = z;
-__exportStar(require("./v4/classic/external.cjs"), exports);
-exports.default = z;

package/assets/mcp/ask-user-server/node_modules/zod/index.d.cts

@@ -1,4 +0,0 @@
-import * as z from "./v4/classic/external.cjs";
-export * from "./v4/classic/external.cjs";
-export { z };
-export default z;

package/assets/mcp/ask-user-server/node_modules/zod/index.d.ts

@@ -1,4 +0,0 @@
-import * as z from "./v4/classic/external.js";
-export * from "./v4/classic/external.js";
-export { z };
-export default z;

package/assets/mcp/ask-user-server/node_modules/zod/index.js

@@ -1,4 +0,0 @@
-import * as z from "./v4/classic/external.js";
-export * from "./v4/classic/external.js";
-export { z };
-export default z;

package/assets/mcp/ask-user-server/node_modules/zod/locales/index.cjs

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../v4/locales/index.cjs"), exports);

package/assets/mcp/ask-user-server/node_modules/zod/locales/index.d.cts

@@ -1 +0,0 @@
-export * from "../v4/locales/index.cjs";

package/assets/mcp/ask-user-server/node_modules/zod/locales/index.d.ts

@@ -1 +0,0 @@
-export * from "../v4/locales/index.js";