@oneie/claude 0.9.0 → 0.10.0

package/scripts/node_modules/json-schema-to-ts/lib/esm/utils/type-guards/validator.js

@@ -1,37 +0,0 @@
-/**
- * Any validator function type (non type-guarding)
- */
-
-/**
- * Adds type guarding to a validator function
- *
- * ```ts
- * const validate: Validator = <S extends JSONSchema, T = FromSchema<S>>(
- *   schema: S,
- *   data: unknown
- * ): data is T => {
- *   const isDataValid: boolean = ... // Implement validation here
- *   return isDataValid;
- * };
- * ```
- */
-
-/**
- * Type definition for wrapValidatorAsTypeGuard
- */
-
-/**
- * Adds type guarding to any validator function (doesn't modify it)
- * @param validator Validator function
- * @returns Validator function with type guarding
- */
-export var wrapValidatorAsTypeGuard = function wrapValidatorAsTypeGuard(validator) {
-  return function (schema, data) {
-    for (var _len = arguments.length, validationOptions = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-      validationOptions[_key - 2] = arguments[_key];
-    }
-
-    return validator.apply(void 0, [schema, data].concat(validationOptions));
-  };
-};
-//# sourceMappingURL=validator.js.map

package/scripts/node_modules/json-schema-to-ts/lib/esm/utils/type-guards/validator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/utils/type-guards/validator.ts"],"names":["wrapValidatorAsTypeGuard","validator","schema","data","validationOptions"],"mappings":"AAOA;AACA;AACA;;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAUA;AACA;AACA;;AAQA;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMA,wBAA0C,GACrD,SADWA,wBACX,CAIEC,SAJF;AAAA,SAMA,UACEC,MADF,EAEEC,IAFF;AAAA,sCAGKC,iBAHL;AAGKA,MAAAA,iBAHL;AAAA;;AAAA,WAKEH,SAAS,MAAT,UAAUC,MAAV,EAAkBC,IAAlB,SAA2BC,iBAA3B,EALF;AAAA,GANA;AAAA,CADK","sourcesContent":["import type {\n  FromSchema,\n  FromSchemaDefaultOptions,\n  FromSchemaOptions,\n  JSONSchema,\n} from \"~/index\";\n\n/**\n * Any validator function type (non type-guarding)\n */\nexport type $Validator<V extends unknown[] = []> = (\n  schema: JSONSchema,\n  data: unknown,\n  ...validationOptions: V\n) => boolean;\n\n/**\n * Adds type guarding to a validator function\n *\n * ```ts\n * const validate: Validator = <S extends JSONSchema, T = FromSchema<S>>(\n *   schema: S,\n *   data: unknown\n * ): data is T => {\n *   const isDataValid: boolean = ... // Implement validation here\n *   return isDataValid;\n * };\n * ```\n */\nexport type Validator<\n  O extends FromSchemaOptions = FromSchemaDefaultOptions,\n  V extends unknown[] = [],\n> = <S extends JSONSchema, T = FromSchema<S, O>>(\n  schema: S,\n  data: unknown,\n  ...validationOptions: V\n) => data is T;\n\n/**\n * Type definition for wrapValidatorAsTypeGuard\n */\ntype ValidatorWrapper = <\n  O extends FromSchemaOptions = FromSchemaDefaultOptions,\n  V extends unknown[] = [],\n>(\n  validator: $Validator<V>,\n) => Validator<O, V>;\n\n/**\n * Adds type guarding to any validator function (doesn't modify it)\n * @param validator Validator function\n * @returns Validator function with type guarding\n */\nexport const wrapValidatorAsTypeGuard: ValidatorWrapper =\n  <\n    O extends FromSchemaOptions = FromSchemaDefaultOptions,\n    V extends unknown[] = [],\n  >(\n    validator: $Validator<V>,\n  ) =>\n  <S extends JSONSchema, T = FromSchema<S, O>>(\n    schema: S,\n    data: unknown,\n    ...validationOptions: V\n  ): data is T =>\n    validator(schema, data, ...validationOptions);\n"],"file":"validator.js"}

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.d.ts

@@ -1,4 +0,0 @@
-export type DeserializationPattern = Readonly<{
-    pattern: unknown;
-    output: unknown;
-}>;

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/extendedJsonSchema.d.ts

@@ -1,75 +0,0 @@
-import type { $JSONSchema, JSONSchemaType } from "./jsonSchema";
-export type JSONSchemaExtension = Record<string, unknown>;
-export type ExtendedJSONSchema<EXTENSION extends JSONSchemaExtension = JSONSchemaExtension> = boolean | (Readonly<{
-    [$JSONSchema]?: $JSONSchema;
-    $id?: string | undefined;
-    $ref?: string | undefined;
-    $schema?: string | undefined;
-    $comment?: string | undefined;
-    type?: JSONSchemaType | readonly JSONSchemaType[];
-    const?: unknown;
-    enum?: unknown;
-    multipleOf?: number | undefined;
-    maximum?: number | undefined;
-    exclusiveMaximum?: number | undefined;
-    minimum?: number | undefined;
-    exclusiveMinimum?: number | undefined;
-    maxLength?: number | undefined;
-    minLength?: number | undefined;
-    pattern?: string | undefined;
-    items?: ExtendedJSONSchema<EXTENSION> | readonly ExtendedJSONSchema<EXTENSION>[];
-    additionalItems?: ExtendedJSONSchema<EXTENSION>;
-    contains?: ExtendedJSONSchema<EXTENSION>;
-    maxItems?: number | undefined;
-    minItems?: number | undefined;
-    uniqueItems?: boolean | undefined;
-    maxProperties?: number | undefined;
-    minProperties?: number | undefined;
-    required?: readonly string[];
-    properties?: Readonly<Record<string, ExtendedJSONSchema<EXTENSION>>>;
-    patternProperties?: Readonly<Record<string, ExtendedJSONSchema<EXTENSION>>>;
-    additionalProperties?: ExtendedJSONSchema<EXTENSION>;
-    dependencies?: Readonly<Record<string, ExtendedJSONSchema<EXTENSION> | readonly string[]>>;
-    propertyNames?: ExtendedJSONSchema<EXTENSION>;
-    if?: ExtendedJSONSchema<EXTENSION>;
-    then?: ExtendedJSONSchema<EXTENSION>;
-    else?: ExtendedJSONSchema<EXTENSION>;
-    allOf?: readonly ExtendedJSONSchema<EXTENSION>[];
-    anyOf?: readonly ExtendedJSONSchema<EXTENSION>[];
-    oneOf?: readonly ExtendedJSONSchema<EXTENSION>[];
-    not?: ExtendedJSONSchema<EXTENSION>;
-    format?: string | undefined;
-    contentMediaType?: string | undefined;
-    contentEncoding?: string | undefined;
-    definitions?: Readonly<Record<string, ExtendedJSONSchema<EXTENSION>>>;
-    title?: string | undefined;
-    description?: string | undefined;
-    default?: unknown;
-    readOnly?: boolean | undefined;
-    writeOnly?: boolean | undefined;
-    examples?: readonly unknown[];
-    nullable?: boolean;
-}> & Readonly<Partial<EXTENSION>>);
-export type ExtendedJSONSchemaReference<EXTENSION extends JSONSchemaExtension = JSONSchemaExtension> = ExtendedJSONSchema<EXTENSION> & Readonly<{
-    $id: string;
-}>;
-type UnextendJSONSchemaTuple<EXTENSION extends JSONSchemaExtension, EXTENDED_SCHEMAS extends ExtendedJSONSchema<EXTENSION>[]> = EXTENDED_SCHEMAS extends [
-    infer EXTENDED_SCHEMAS_HEAD,
-    ...infer EXTENDED_SCHEMAS_TAIL
-] ? EXTENDED_SCHEMAS_HEAD extends ExtendedJSONSchema<EXTENSION> ? EXTENDED_SCHEMAS_TAIL extends ExtendedJSONSchema<EXTENSION>[] ? [
-    UnextendJSONSchema<EXTENSION, EXTENDED_SCHEMAS_HEAD>,
-    ...UnextendJSONSchemaTuple<EXTENSION, EXTENDED_SCHEMAS_TAIL>
-] : never : never : [];
-type UnextendJSONSchemaRecord<EXTENSION extends JSONSchemaExtension, EXTENDED_SCHEMA_RECORD extends Record<string, unknown>> = {
-    [KEY in keyof EXTENDED_SCHEMA_RECORD]: EXTENDED_SCHEMA_RECORD[KEY] extends ExtendedJSONSchema<EXTENSION> ? UnextendJSONSchema<EXTENSION, EXTENDED_SCHEMA_RECORD[KEY]> : EXTENDED_SCHEMA_RECORD[KEY];
-};
-export type UnextendJSONSchema<EXTENSION extends JSONSchemaExtension, EXTENDED_SCHEMA> = EXTENDED_SCHEMA extends boolean ? EXTENDED_SCHEMA : {
-    [KEY in $JSONSchema | keyof EXTENDED_SCHEMA]: KEY extends keyof EXTENDED_SCHEMA ? EXTENDED_SCHEMA extends {
-        [K in KEY]: ExtendedJSONSchema<EXTENSION>;
-    } ? UnextendJSONSchema<EXTENSION, EXTENDED_SCHEMA[KEY]> : EXTENDED_SCHEMA extends {
-        [K in KEY]: ExtendedJSONSchema<EXTENSION>[];
-    } ? number extends EXTENDED_SCHEMA[KEY]["length"] ? UnextendJSONSchema<EXTENSION, EXTENDED_SCHEMA[KEY][number]>[] : EXTENDED_SCHEMA[KEY] extends ExtendedJSONSchema<EXTENSION>[] ? UnextendJSONSchemaTuple<EXTENSION, EXTENDED_SCHEMA[KEY]> : never : EXTENDED_SCHEMA extends {
-        [K in KEY]: Record<string, unknown>;
-    } ? UnextendJSONSchemaRecord<EXTENSION, EXTENDED_SCHEMA[KEY]> : EXTENDED_SCHEMA[KEY] : KEY extends $JSONSchema ? $JSONSchema : never;
-};
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/extendedJsonSchema.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/fromSchemaOptions.d.ts

@@ -1,24 +0,0 @@
-import type { JSONSchemaReference } from "../definitions";
-import type { DeserializationPattern } from "./deserializationPattern";
-import type { ExtendedJSONSchemaReference, JSONSchemaExtension } from "./extendedJsonSchema";
-export type FromSchemaOptions = {
-    parseNotKeyword?: boolean;
-    parseIfThenElseKeywords?: boolean;
-    keepDefaultedPropertiesOptional?: boolean;
-    references?: JSONSchemaReference[] | false;
-    deserialize?: DeserializationPattern[] | false;
-};
-export type FromExtendedSchemaOptions<EXTENSION extends JSONSchemaExtension> = {
-    parseNotKeyword?: boolean;
-    parseIfThenElseKeywords?: boolean;
-    keepDefaultedPropertiesOptional?: boolean;
-    references?: ExtendedJSONSchemaReference<EXTENSION>[] | false;
-    deserialize?: DeserializationPattern[] | false;
-};
-export type FromSchemaDefaultOptions = {
-    parseNotKeyword: false;
-    parseIfThenElseKeywords: false;
-    keepDefaultedPropertiesOptional: false;
-    references: false;
-    deserialize: false;
-};

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/fromSchemaOptions.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/index.d.ts

@@ -1,4 +0,0 @@
-export type { DeserializationPattern } from "./deserializationPattern";
-export type { JSONSchema, JSONSchemaType, JSONSchemaReference, } from "./jsonSchema";
-export type { FromSchemaOptions, FromExtendedSchemaOptions, FromSchemaDefaultOptions, } from "./fromSchemaOptions";
-export type { JSONSchemaExtension, ExtendedJSONSchema, ExtendedJSONSchemaReference, UnextendJSONSchema, } from "./extendedJsonSchema";

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/index.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.d.ts

@@ -1,57 +0,0 @@
-export declare const $JSONSchema: unique symbol;
-export type $JSONSchema = typeof $JSONSchema;
-export type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
-export type JSONSchema = boolean | Readonly<{
-    [$JSONSchema]?: $JSONSchema;
-    $id?: string | undefined;
-    $ref?: string | undefined;
-    $schema?: string | undefined;
-    $comment?: string | undefined;
-    type?: JSONSchemaType | readonly JSONSchemaType[];
-    const?: unknown;
-    enum?: unknown;
-    multipleOf?: number | undefined;
-    maximum?: number | undefined;
-    exclusiveMaximum?: number | undefined;
-    minimum?: number | undefined;
-    exclusiveMinimum?: number | undefined;
-    maxLength?: number | undefined;
-    minLength?: number | undefined;
-    pattern?: string | undefined;
-    items?: JSONSchema | readonly JSONSchema[];
-    additionalItems?: JSONSchema;
-    contains?: JSONSchema;
-    maxItems?: number | undefined;
-    minItems?: number | undefined;
-    uniqueItems?: boolean | undefined;
-    maxProperties?: number | undefined;
-    minProperties?: number | undefined;
-    required?: readonly string[];
-    properties?: Readonly<Record<string, JSONSchema>>;
-    patternProperties?: Readonly<Record<string, JSONSchema>>;
-    additionalProperties?: JSONSchema;
-    unevaluatedProperties?: JSONSchema;
-    dependencies?: Readonly<Record<string, JSONSchema | readonly string[]>>;
-    propertyNames?: JSONSchema;
-    if?: JSONSchema;
-    then?: JSONSchema;
-    else?: JSONSchema;
-    allOf?: readonly JSONSchema[];
-    anyOf?: readonly JSONSchema[];
-    oneOf?: readonly JSONSchema[];
-    not?: JSONSchema;
-    format?: string | undefined;
-    contentMediaType?: string | undefined;
-    contentEncoding?: string | undefined;
-    definitions?: Readonly<Record<string, JSONSchema>>;
-    title?: string | undefined;
-    description?: string | undefined;
-    default?: unknown;
-    readOnly?: boolean | undefined;
-    writeOnly?: boolean | undefined;
-    examples?: readonly unknown[];
-    nullable?: boolean;
-}>;
-export type JSONSchemaReference = JSONSchema & Readonly<{
-    $id: string;
-}>;

package/scripts/node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.js

@@ -1 +0,0 @@
-export const $JSONSchema = Symbol("$JSONSchema");

package/scripts/node_modules/json-schema-to-ts/lib/types/index.d.ts

@@ -1,9 +0,0 @@
-import type { M } from "ts-algebra";
-import type { ExtendedJSONSchema, FromExtendedSchemaOptions, FromSchemaDefaultOptions, FromSchemaOptions, JSONSchema, JSONSchemaExtension, UnextendJSONSchema } from "./definitions";
-import type { ParseOptions } from "./parse-options";
-import type { ParseSchema } from "./parse-schema";
-export type { ExtendedJSONSchema, DeserializationPattern, FromSchemaOptions, FromExtendedSchemaOptions, FromSchemaDefaultOptions, JSONSchemaExtension, JSONSchema, } from "./definitions";
-export type { $Compiler, Compiler, $Validator, Validator } from "./utils";
-export { wrapCompilerAsTypeGuard, wrapValidatorAsTypeGuard, asConst, } from "./utils";
-export type FromSchema<SCHEMA extends JSONSchema, OPTIONS extends FromSchemaOptions = FromSchemaDefaultOptions> = M.$Resolve<ParseSchema<SCHEMA, ParseOptions<SCHEMA, OPTIONS>>>;
-export type FromExtendedSchema<EXTENSION extends JSONSchemaExtension, SCHEMA extends ExtendedJSONSchema<EXTENSION>, OPTIONS extends FromExtendedSchemaOptions<EXTENSION> = FromSchemaDefaultOptions, UNEXTENDED_SCHEMA = UnextendJSONSchema<EXTENSION, SCHEMA>> = UNEXTENDED_SCHEMA extends JSONSchema ? FromSchema<UNEXTENDED_SCHEMA, OPTIONS> : never;

package/scripts/node_modules/json-schema-to-ts/lib/types/index.js

@@ -1 +0,0 @@
-export { wrapCompilerAsTypeGuard, wrapValidatorAsTypeGuard, asConst, } from "./utils";

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-options.d.ts

@@ -1,12 +0,0 @@
-import type { DeserializationPattern, FromSchemaDefaultOptions, FromSchemaOptions, JSONSchema, JSONSchemaReference } from "./definitions";
-export type IndexReferencesById<SCHEMA_REFERENCES extends readonly JSONSchemaReference[]> = {
-    [REF_SCHEMA in SCHEMA_REFERENCES[number] as REF_SCHEMA["$id"]]: REF_SCHEMA;
-};
-export type ParseOptions<ROOT_SCHEMA extends JSONSchema, OPTIONS extends FromSchemaOptions> = {
-    parseNotKeyword: OPTIONS["parseNotKeyword"] extends boolean ? OPTIONS["parseNotKeyword"] : FromSchemaDefaultOptions["parseNotKeyword"];
-    parseIfThenElseKeywords: OPTIONS["parseIfThenElseKeywords"] extends boolean ? OPTIONS["parseIfThenElseKeywords"] : FromSchemaDefaultOptions["parseIfThenElseKeywords"];
-    keepDefaultedPropertiesOptional: OPTIONS["keepDefaultedPropertiesOptional"] extends boolean ? OPTIONS["keepDefaultedPropertiesOptional"] : FromSchemaDefaultOptions["keepDefaultedPropertiesOptional"];
-    rootSchema: ROOT_SCHEMA;
-    references: OPTIONS["references"] extends JSONSchemaReference[] ? IndexReferencesById<OPTIONS["references"]> : {};
-    deserialize: OPTIONS["deserialize"] extends DeserializationPattern[] | false ? OPTIONS["deserialize"] : FromSchemaDefaultOptions["deserialize"];
-};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-options.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/allOf.d.ts

@@ -1,13 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-import type { MergeSubSchema } from "./utils";
-export type AllOfSchema = JSONSchema & Readonly<{
-    allOf: readonly JSONSchema[];
-}>;
-export type ParseAllOfSchema<ALL_OF_SCHEMA extends AllOfSchema, OPTIONS extends ParseSchemaOptions> = RecurseOnAllOfSchema<ALL_OF_SCHEMA["allOf"], ALL_OF_SCHEMA, OPTIONS, ParseSchema<Omit<ALL_OF_SCHEMA, "allOf">, OPTIONS>>;
-type RecurseOnAllOfSchema<SUB_SCHEMAS extends readonly JSONSchema[], ROOT_ALL_OF_SCHEMA extends AllOfSchema, OPTIONS extends ParseSchemaOptions, PARSED_ROOT_ALL_OF_SCHEMA> = SUB_SCHEMAS extends readonly [
-    infer SUB_SCHEMAS_HEAD,
-    ...infer SUB_SCHEMAS_TAIL
-] ? SUB_SCHEMAS_HEAD extends JSONSchema ? SUB_SCHEMAS_TAIL extends readonly JSONSchema[] ? RecurseOnAllOfSchema<SUB_SCHEMAS_TAIL, ROOT_ALL_OF_SCHEMA, OPTIONS, M.$Intersect<ParseSchema<MergeSubSchema<Omit<ROOT_ALL_OF_SCHEMA, "allOf">, SUB_SCHEMAS_HEAD>, OPTIONS>, PARSED_ROOT_ALL_OF_SCHEMA>> : never : never : PARSED_ROOT_ALL_OF_SCHEMA;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/allOf.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/anyOf.d.ts

@@ -1,13 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-import type { MergeSubSchema } from "./utils";
-export type AnyOfSchema = JSONSchema & Readonly<{
-    anyOf: readonly JSONSchema[];
-}>;
-export type ParseAnyOfSchema<ANY_OF_SCHEMA extends AnyOfSchema, OPTIONS extends ParseSchemaOptions> = M.$Union<RecurseOnAnyOfSchema<ANY_OF_SCHEMA["anyOf"], ANY_OF_SCHEMA, OPTIONS>>;
-type RecurseOnAnyOfSchema<SUB_SCHEMAS extends readonly JSONSchema[], ROOT_ANY_OF_SCHEMA extends AnyOfSchema, OPTIONS extends ParseSchemaOptions, RESULT = never> = SUB_SCHEMAS extends readonly [
-    infer SUB_SCHEMAS_HEAD,
-    ...infer SUB_SCHEMAS_TAIL
-] ? SUB_SCHEMAS_HEAD extends JSONSchema ? SUB_SCHEMAS_TAIL extends readonly JSONSchema[] ? RecurseOnAnyOfSchema<SUB_SCHEMAS_TAIL, ROOT_ANY_OF_SCHEMA, OPTIONS, RESULT | M.$Intersect<ParseSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, OPTIONS>, ParseSchema<MergeSubSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, SUB_SCHEMAS_HEAD>, OPTIONS>>> : never : never : RESULT;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/anyOf.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/array.d.ts

@@ -1,57 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { And, DoesExtend, Not, Tail } from "../type-utils";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-export type ArrayOrTupleSchema = JSONSchema & Readonly<{
-    type: "array";
-}>;
-export type ArraySchema = Omit<JSONSchema, "items"> & Readonly<{
-    type: "array";
-    items: JSONSchema;
-}>;
-export type TupleSchema = JSONSchema & Readonly<{
-    type: "array";
-    items: readonly JSONSchema[];
-}>;
-export type ParseArrayOrTupleSchema<ARRAY_OR_TUPLE_SCHEMA extends ArrayOrTupleSchema, OPTIONS extends ParseSchemaOptions> = ARRAY_OR_TUPLE_SCHEMA extends ArraySchema ? M.$Array<ParseSchema<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>> : ARRAY_OR_TUPLE_SCHEMA extends TupleSchema ? M.$Union<ApplyMinMaxAndAdditionalItems<ParseTupleItems<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>, ARRAY_OR_TUPLE_SCHEMA, OPTIONS>> : M.$Array;
-type ParseTupleItems<ITEM_SCHEMAS extends readonly JSONSchema[], OPTIONS extends ParseSchemaOptions> = ITEM_SCHEMAS extends readonly [
-    infer ITEM_SCHEMAS_HEAD,
-    ...infer ITEM_SCHEMAS_TAIL
-] ? ITEM_SCHEMAS_HEAD extends JSONSchema ? ITEM_SCHEMAS_TAIL extends readonly JSONSchema[] ? [
-    ParseSchema<ITEM_SCHEMAS_HEAD, OPTIONS>,
-    ...ParseTupleItems<ITEM_SCHEMAS_TAIL, OPTIONS>
-] : never : never : [];
-type ApplyMinMaxAndAdditionalItems<PARSED_ITEM_SCHEMAS extends any[], ROOT_SCHEMA extends ArrayOrTupleSchema, OPTIONS extends ParseSchemaOptions> = ApplyAdditionalItems<ApplyMinMax<PARSED_ITEM_SCHEMAS, ROOT_SCHEMA extends Readonly<{
-    minItems: number;
-}> ? ROOT_SCHEMA["minItems"] : 0, ROOT_SCHEMA extends Readonly<{
-    maxItems: number;
-}> ? ROOT_SCHEMA["maxItems"] : undefined>, ROOT_SCHEMA extends Readonly<{
-    additionalItems: JSONSchema;
-}> ? ROOT_SCHEMA["additionalItems"] : true, OPTIONS>;
-type ApplyMinMax<RECURSED_PARSED_ITEM_SCHEMAS extends any[], MIN extends number, MAX extends number | undefined, RESULT = never, HAS_ENCOUNTERED_MIN extends boolean = false, HAS_ENCOUNTERED_MAX extends boolean = false, INITIAL_PARSED_ITEM_SCHEMAS extends any[] = RECURSED_PARSED_ITEM_SCHEMAS> = And<Not<DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>>, DoesExtend<RECURSED_PARSED_ITEM_SCHEMAS, [any, ...any[]]>> extends true ? RECURSED_PARSED_ITEM_SCHEMAS extends [
-    ...infer RECURSED_PARSED_ITEM_SCHEMAS_BODY,
-    unknown
-] ? ApplyMinMax<RECURSED_PARSED_ITEM_SCHEMAS_BODY, MIN, MAX, RECURSED_PARSED_ITEM_SCHEMAS["length"] extends MAX ? M.$Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : RESULT | M.$Tuple<RECURSED_PARSED_ITEM_SCHEMAS>, HAS_ENCOUNTERED_MIN extends true ? true : DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>, HAS_ENCOUNTERED_MAX extends true ? true : DoesExtend<MAX, RECURSED_PARSED_ITEM_SCHEMAS["length"]>, INITIAL_PARSED_ITEM_SCHEMAS> : never : {
-    result: MAX extends undefined ? RESULT | M.$Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : HAS_ENCOUNTERED_MAX extends true ? RESULT | M.$Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : MAX extends RECURSED_PARSED_ITEM_SCHEMAS["length"] ? M.$Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : IsLongerThan<Tail<RECURSED_PARSED_ITEM_SCHEMAS>, MAX> extends true ? never : RESULT | M.$Tuple<RECURSED_PARSED_ITEM_SCHEMAS>;
-    hasEncounteredMin: DoesExtend<MIN, RECURSED_PARSED_ITEM_SCHEMAS["length"]>;
-    hasEncounteredMax: HAS_ENCOUNTERED_MAX extends true ? true : MAX extends RECURSED_PARSED_ITEM_SCHEMAS["length"] ? true : IsLongerThan<Tail<RECURSED_PARSED_ITEM_SCHEMAS>, MAX>;
-    completeTuple: INITIAL_PARSED_ITEM_SCHEMAS;
-};
-type IsLongerThan<TUPLE extends any[], LENGTH extends number | undefined, RESULT extends boolean = false> = LENGTH extends undefined ? false : TUPLE["length"] extends LENGTH ? true : TUPLE extends [any, ...infer TUPLE_TAIL] ? IsLongerThan<TUPLE_TAIL, LENGTH> : RESULT;
-type ApplyAdditionalItems<APPLY_MIN_MAX_RESULT extends {
-    result: any;
-    hasEncounteredMin: boolean;
-    hasEncounteredMax: boolean;
-    completeTuple: any[];
-}, ADDITIONAL_ITEMS_SCHEMA extends JSONSchema, OPTIONS extends ParseSchemaOptions> = APPLY_MIN_MAX_RESULT extends {
-    hasEncounteredMax: true;
-} ? APPLY_MIN_MAX_RESULT extends {
-    hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] : M.Never : ADDITIONAL_ITEMS_SCHEMA extends false ? APPLY_MIN_MAX_RESULT extends {
-    hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] : M.Never : ADDITIONAL_ITEMS_SCHEMA extends true ? APPLY_MIN_MAX_RESULT extends {
-    hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] | M.$Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], M.Any> : M.$Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], M.Any> : APPLY_MIN_MAX_RESULT extends {
-    hasEncounteredMin: true;
-} ? APPLY_MIN_MAX_RESULT["result"] | M.$Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>> : M.$Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>>;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/array.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/const.d.ts

@@ -1,10 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { Writable } from "../type-utils";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-export type ConstSchema = JSONSchema & Readonly<{
-    const: unknown;
-}>;
-export type ParseConstSchema<CONST_SCHEMA extends ConstSchema, OPTIONS extends ParseSchemaOptions> = M.$Intersect<ParseConst<CONST_SCHEMA>, ParseSchema<Omit<CONST_SCHEMA, "const">, OPTIONS>>;
-type ParseConst<CONST_SCHEMA extends ConstSchema> = M.Const<Writable<CONST_SCHEMA["const"]>>;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/const.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/deserialize.d.ts

@@ -1,11 +0,0 @@
-import type { M } from "ts-algebra";
-import type { DeserializationPattern, JSONSchema } from "../definitions";
-import type { ParseSchemaOptions } from "./index";
-export type DeserializeSchema<SCHEMA extends JSONSchema, OPTIONS extends Omit<ParseSchemaOptions, "deserialize"> & {
-    deserialize: DeserializationPattern[];
-}> = RecurseOnDeserializationPatterns<SCHEMA, OPTIONS["deserialize"]>;
-type RecurseOnDeserializationPatterns<SCHEMA extends JSONSchema, DESERIALIZATION_PATTERNS extends DeserializationPattern[], RESULT = M.Any> = DESERIALIZATION_PATTERNS extends [
-    infer DESERIALIZATION_PATTERNS_HEAD,
-    ...infer DESERIALIZATION_PATTERNS_TAIL
-] ? DESERIALIZATION_PATTERNS_HEAD extends DeserializationPattern ? DESERIALIZATION_PATTERNS_TAIL extends DeserializationPattern[] ? RecurseOnDeserializationPatterns<SCHEMA, DESERIALIZATION_PATTERNS_TAIL, SCHEMA extends DESERIALIZATION_PATTERNS_HEAD["pattern"] ? M.$Intersect<M.Any<true, DESERIALIZATION_PATTERNS_HEAD["output"]>, RESULT> : RESULT> : never : never : RESULT;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/deserialize.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/enum.d.ts

@@ -1,10 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { Writable } from "../type-utils";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-export type EnumSchema = JSONSchema & Readonly<{
-    enum: readonly unknown[];
-}>;
-export type ParseEnumSchema<ENUM_SCHEMA extends EnumSchema, OPTIONS extends ParseSchemaOptions> = M.$Intersect<ParseEnum<ENUM_SCHEMA>, ParseSchema<Omit<ENUM_SCHEMA, "enum">, OPTIONS>>;
-type ParseEnum<ENUM_SCHEMA extends EnumSchema> = M.Enum<Writable<ENUM_SCHEMA["enum"][number]>>;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/enum.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/ifThenElse.d.ts

@@ -1,14 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-import type { MergeSubSchema } from "./utils";
-export type IfThenElseSchema = JSONSchema & {
-    if: JSONSchema;
-    then?: JSONSchema;
-    else?: JSONSchema;
-};
-export type ParseIfThenElseSchema<IF_THEN_ELSE_SCHEMA extends IfThenElseSchema, OPTIONS extends ParseSchemaOptions, REST_SCHEMA extends JSONSchema = Omit<IF_THEN_ELSE_SCHEMA, "if" | "then" | "else">, IF_SCHEMA extends JSONSchema = MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["if"]>, PARSED_THEN_SCHEMA = IF_THEN_ELSE_SCHEMA extends {
-    then: JSONSchema;
-} ? M.$Intersect<ParseSchema<IF_SCHEMA, OPTIONS>, ParseSchema<MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["then"]>, OPTIONS>> : ParseSchema<IF_SCHEMA, OPTIONS>, PARSED_ELSE_SCHEMA = IF_THEN_ELSE_SCHEMA extends {
-    else: JSONSchema;
-} ? M.$Intersect<M.$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>, ParseSchema<MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["else"]>, OPTIONS>> : M.$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>> = M.$Intersect<M.$Union<PARSED_THEN_SCHEMA | PARSED_ELSE_SCHEMA>, ParseSchema<REST_SCHEMA, OPTIONS>>;

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/ifThenElse.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/index.d.ts

@@ -1,26 +0,0 @@
-import type { M } from "ts-algebra";
-import type { DeserializationPattern, JSONSchema } from "../definitions";
-import type { And, DoesExtend } from "../type-utils";
-import type { AllOfSchema, ParseAllOfSchema } from "./allOf";
-import type { AnyOfSchema, ParseAnyOfSchema } from "./anyOf";
-import type { ConstSchema, ParseConstSchema } from "./const";
-import type { DeserializeSchema } from "./deserialize";
-import type { EnumSchema, ParseEnumSchema } from "./enum";
-import type { IfThenElseSchema, ParseIfThenElseSchema } from "./ifThenElse";
-import type { MultipleTypesSchema, ParseMultipleTypesSchema } from "./multipleTypes";
-import type { NotSchema, ParseNotSchema } from "./not";
-import type { NullableSchema, ParseNullableSchema } from "./nullable";
-import type { OneOfSchema, ParseOneOfSchema } from "./oneOf";
-import type { ParseReferenceSchema, ReferencingSchema } from "./references";
-import type { ParseSingleTypeSchema, SingleTypeSchema } from "./singleType";
-export type ParseSchemaOptions = {
-    parseNotKeyword: boolean;
-    parseIfThenElseKeywords: boolean;
-    keepDefaultedPropertiesOptional: boolean;
-    rootSchema: JSONSchema;
-    references: Record<string, JSONSchema>;
-    deserialize: DeserializationPattern[] | false;
-};
-export type ParseSchema<SCHEMA extends JSONSchema, OPTIONS extends ParseSchemaOptions, RESULT = JSONSchema extends SCHEMA ? M.Any : SCHEMA extends true | string ? M.Any : SCHEMA extends false ? M.Never : SCHEMA extends NullableSchema ? ParseNullableSchema<SCHEMA, OPTIONS> : SCHEMA extends ReferencingSchema ? ParseReferenceSchema<SCHEMA, OPTIONS> : And<DoesExtend<OPTIONS["parseIfThenElseKeywords"], true>, DoesExtend<SCHEMA, IfThenElseSchema>> extends true ? SCHEMA extends IfThenElseSchema ? ParseIfThenElseSchema<SCHEMA, OPTIONS> : never : And<DoesExtend<OPTIONS["parseNotKeyword"], true>, DoesExtend<SCHEMA, NotSchema>> extends true ? SCHEMA extends NotSchema ? ParseNotSchema<SCHEMA, OPTIONS> : never : SCHEMA extends AllOfSchema ? ParseAllOfSchema<SCHEMA, OPTIONS> : SCHEMA extends OneOfSchema ? ParseOneOfSchema<SCHEMA, OPTIONS> : SCHEMA extends AnyOfSchema ? ParseAnyOfSchema<SCHEMA, OPTIONS> : SCHEMA extends EnumSchema ? ParseEnumSchema<SCHEMA, OPTIONS> : SCHEMA extends ConstSchema ? ParseConstSchema<SCHEMA, OPTIONS> : SCHEMA extends MultipleTypesSchema ? ParseMultipleTypesSchema<SCHEMA, OPTIONS> : SCHEMA extends SingleTypeSchema ? ParseSingleTypeSchema<SCHEMA, OPTIONS> : M.Any> = OPTIONS extends {
-    deserialize: DeserializationPattern[];
-} ? M.$Intersect<DeserializeSchema<SCHEMA, OPTIONS>, RESULT> : RESULT;

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/index.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/multipleTypes.d.ts

@@ -1,11 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema, JSONSchemaType } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-export type MultipleTypesSchema = JSONSchema & Readonly<{
-    type: readonly JSONSchemaType[];
-}>;
-export type ParseMultipleTypesSchema<MULTI_TYPE_SCHEMA extends MultipleTypesSchema, OPTIONS extends ParseSchemaOptions> = M.$Union<RecurseOnMixedSchema<MULTI_TYPE_SCHEMA["type"], MULTI_TYPE_SCHEMA, OPTIONS>>;
-type RecurseOnMixedSchema<TYPES extends readonly JSONSchemaType[], ROOT_MULTI_TYPE_SCHEMA extends MultipleTypesSchema, OPTIONS extends ParseSchemaOptions, RESULT = never> = TYPES extends readonly [infer TYPES_HEAD, ...infer TYPES_TAIL] ? TYPES_HEAD extends JSONSchemaType ? TYPES_TAIL extends readonly JSONSchemaType[] ? RecurseOnMixedSchema<TYPES_TAIL, ROOT_MULTI_TYPE_SCHEMA, OPTIONS, RESULT | ParseSchema<Omit<ROOT_MULTI_TYPE_SCHEMA, "type"> & {
-    type: TYPES_HEAD;
-}, OPTIONS>> : never : never : RESULT;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/multipleTypes.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/not.d.ts

@@ -1,10 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-import type { MergeSubSchema } from "./utils";
-export type NotSchema = JSONSchema & Readonly<{
-    not: JSONSchema;
-}>;
-type AllTypes = M.Union<M.Primitive<null> | M.Primitive<boolean> | M.Primitive<number> | M.Primitive<string> | M.Array | M.Object<{}, never, M.Any>>;
-export type ParseNotSchema<NOT_SCHEMA extends NotSchema, OPTIONS extends ParseSchemaOptions, PARSED_REST_SCHEMA = ParseSchema<Omit<NOT_SCHEMA, "not">, OPTIONS>, EXCLUSION = M.$Exclude<PARSED_REST_SCHEMA extends M.AnyType ? M.$Intersect<AllTypes, PARSED_REST_SCHEMA> : PARSED_REST_SCHEMA, ParseSchema<MergeSubSchema<Omit<NOT_SCHEMA, "not">, NOT_SCHEMA["not"]>, OPTIONS>>> = EXCLUSION extends M.Never ? PARSED_REST_SCHEMA : EXCLUSION;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/not.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/nullable.d.ts

@@ -1,9 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-export type NullableSchema = JSONSchema & Readonly<{
-    nullable: boolean;
-}>;
-export type ParseNullableSchema<NULLABLE_SCHEMA extends NullableSchema, OPTIONS extends ParseSchemaOptions, PARSED_REST_SCHEMA = ParseSchema<Omit<NULLABLE_SCHEMA, "nullable">, OPTIONS>> = NULLABLE_SCHEMA extends Readonly<{
-    nullable: true;
-}> ? M.$Union<M.Primitive<null> | PARSED_REST_SCHEMA> : PARSED_REST_SCHEMA;

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/nullable.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/object.d.ts

@@ -1,37 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-export type ObjectSchema = JSONSchema & Readonly<{
-    type: "object";
-}>;
-export type ParseObjectSchema<OBJECT_SCHEMA extends ObjectSchema, OPTIONS extends ParseSchemaOptions> = OBJECT_SCHEMA extends Readonly<{
-    properties: Readonly<Record<string, JSONSchema>>;
-}> ? M.$Object<{
-    [KEY in keyof OBJECT_SCHEMA["properties"]]: ParseSchema<OBJECT_SCHEMA["properties"][KEY], OPTIONS>;
-}, GetRequired<OBJECT_SCHEMA, OPTIONS>, GetOpenProps<OBJECT_SCHEMA, OPTIONS>, GetClosedOnResolve<OBJECT_SCHEMA>> : M.$Object<{}, GetRequired<OBJECT_SCHEMA, OPTIONS>, GetOpenProps<OBJECT_SCHEMA, OPTIONS>, GetClosedOnResolve<OBJECT_SCHEMA>>;
-type GetRequired<OBJECT_SCHEMA extends ObjectSchema, OPTIONS extends ParseSchemaOptions> = (OBJECT_SCHEMA extends Readonly<{
-    required: ReadonlyArray<string>;
-}> ? OBJECT_SCHEMA["required"][number] : never) | (OPTIONS["keepDefaultedPropertiesOptional"] extends true ? never : OBJECT_SCHEMA extends Readonly<{
-    properties: Readonly<Record<string, JSONSchema>>;
-}> ? {
-    [KEY in keyof OBJECT_SCHEMA["properties"] & string]: OBJECT_SCHEMA["properties"][KEY] extends Readonly<{
-        default: unknown;
-    }> ? KEY : never;
-}[keyof OBJECT_SCHEMA["properties"] & string] : never);
-type GetOpenProps<OBJECT_SCHEMA extends ObjectSchema, OPTIONS extends ParseSchemaOptions> = OBJECT_SCHEMA extends Readonly<{
-    additionalProperties: JSONSchema;
-}> ? OBJECT_SCHEMA extends Readonly<{
-    patternProperties: Record<string, JSONSchema>;
-}> ? AdditionalAndPatternProps<OBJECT_SCHEMA["additionalProperties"], OBJECT_SCHEMA["patternProperties"], OPTIONS> : ParseSchema<OBJECT_SCHEMA["additionalProperties"], OPTIONS> : OBJECT_SCHEMA extends Readonly<{
-    patternProperties: Record<string, JSONSchema>;
-}> ? PatternProps<OBJECT_SCHEMA["patternProperties"], OPTIONS> : M.Any;
-type GetClosedOnResolve<OBJECT_SCHEMA extends ObjectSchema> = OBJECT_SCHEMA extends Readonly<{
-    unevaluatedProperties: false;
-}> ? true : false;
-type PatternProps<PATTERN_PROPERTY_SCHEMAS extends Readonly<Record<string, JSONSchema>>, OPTIONS extends ParseSchemaOptions> = M.$Union<{
-    [KEY in keyof PATTERN_PROPERTY_SCHEMAS]: ParseSchema<PATTERN_PROPERTY_SCHEMAS[KEY], OPTIONS>;
-}[keyof PATTERN_PROPERTY_SCHEMAS]>;
-type AdditionalAndPatternProps<ADDITIONAL_PROPERTIES_SCHEMA extends JSONSchema, PATTERN_PROPERTY_SCHEMAS extends Readonly<Record<string, JSONSchema>>, OPTIONS extends ParseSchemaOptions> = ADDITIONAL_PROPERTIES_SCHEMA extends boolean ? PatternProps<PATTERN_PROPERTY_SCHEMAS, OPTIONS> : M.$Union<ParseSchema<ADDITIONAL_PROPERTIES_SCHEMA, OPTIONS> | {
-    [KEY in keyof PATTERN_PROPERTY_SCHEMAS]: ParseSchema<PATTERN_PROPERTY_SCHEMAS[KEY], OPTIONS>;
-}[keyof PATTERN_PROPERTY_SCHEMAS]>;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/object.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/oneOf.d.ts

@@ -1,13 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../definitions";
-import type { ParseSchema, ParseSchemaOptions } from "./index";
-import type { MergeSubSchema } from "./utils";
-export type OneOfSchema = JSONSchema & Readonly<{
-    oneOf: readonly JSONSchema[];
-}>;
-export type ParseOneOfSchema<ONE_OF_SCHEMA extends OneOfSchema, OPTIONS extends ParseSchemaOptions> = M.$Union<RecurseOnOneOfSchema<ONE_OF_SCHEMA["oneOf"], ONE_OF_SCHEMA, OPTIONS>>;
-type RecurseOnOneOfSchema<SUB_SCHEMAS extends readonly JSONSchema[], ROOT_ONE_OF_SCHEMA extends OneOfSchema, OPTIONS extends ParseSchemaOptions, RESULT = never> = SUB_SCHEMAS extends readonly [
-    infer SUB_SCHEMAS_HEAD,
-    ...infer SUB_SCHEMAS_TAIL
-] ? SUB_SCHEMAS_HEAD extends JSONSchema ? SUB_SCHEMAS_TAIL extends readonly JSONSchema[] ? RecurseOnOneOfSchema<SUB_SCHEMAS_TAIL, ROOT_ONE_OF_SCHEMA, OPTIONS, RESULT | M.$Intersect<ParseSchema<Omit<ROOT_ONE_OF_SCHEMA, "oneOf">, OPTIONS>, ParseSchema<MergeSubSchema<Omit<ROOT_ONE_OF_SCHEMA, "oneOf">, SUB_SCHEMAS_HEAD>, OPTIONS>>> : never : never : RESULT;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/oneOf.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/references/external.d.ts

@@ -1,22 +0,0 @@
-import type { M } from "ts-algebra";
-import type { JSONSchema } from "../../definitions";
-import type { Join, Pop, Split } from "../../type-utils";
-import type { ParseSchemaOptions } from "../index";
-import type { ReferencingSchema } from "./index";
-import type { ParseReference } from "./utils";
-export type ParseExternalReferenceSchema<REF_SCHEMA extends ReferencingSchema, OPTIONS extends ParseSchemaOptions, EXTERNAL_REFERENCE_ID extends string, SUB_PATH extends string | undefined> = OPTIONS["references"] extends {
-    [KEY in EXTERNAL_REFERENCE_ID]: JSONSchema;
-} ? ParseReference<Omit<REF_SCHEMA, "$ref">, OPTIONS, OPTIONS["references"][EXTERNAL_REFERENCE_ID], SUB_PATH> : OPTIONS extends {
-    rootSchema: IdSchema;
-} ? ParseExternalReferenceWithoutDirectorySchema<Omit<REF_SCHEMA, "$ref">, OPTIONS, EXTERNAL_REFERENCE_ID, SUB_PATH> : M.Never;
-type ParseDirectory<REFERENCE extends string> = Join<Pop<Split<REFERENCE, "/">>, "/">;
-type IdSchema = JSONSchema & {
-    $id: string;
-};
-type ParseExternalReferenceWithoutDirectorySchema<SUB_SCHEMA extends JSONSchema, OPTIONS extends ParseSchemaOptions & {
-    rootSchema: IdSchema;
-}, EXTERNAL_REFERENCE_ID extends string, SUB_PATH extends string | undefined, DIRECTORY extends string = ParseDirectory<OPTIONS["rootSchema"]["$id"]>, COMPLETE_REFERENCE extends string = Join<[
-    DIRECTORY,
-    EXTERNAL_REFERENCE_ID
-], "/">> = COMPLETE_REFERENCE extends keyof OPTIONS["references"] ? ParseReference<SUB_SCHEMA, OPTIONS, OPTIONS["references"][COMPLETE_REFERENCE], SUB_PATH> : M.Never;
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/references/external.js

@@ -1 +0,0 @@
-export {};

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/references/index.d.ts

@@ -1,9 +0,0 @@
-import type { JSONSchema } from "../../definitions";
-import type { Split } from "../../type-utils/split";
-import type { ParseSchemaOptions } from "../index";
-import type { ParseExternalReferenceSchema } from "./external";
-import type { ParseInternalReferenceSchema } from "./internal";
-export type ReferencingSchema = JSONSchema & {
-    $ref: string;
-};
-export type ParseReferenceSchema<REFERENCING_SCHEMA extends ReferencingSchema, OPTIONS extends ParseSchemaOptions, REFERENCE_ID_AND_PATH extends string[] = Split<REFERENCING_SCHEMA["$ref"], "#">> = REFERENCE_ID_AND_PATH[0] extends "" ? ParseInternalReferenceSchema<REFERENCING_SCHEMA, OPTIONS, REFERENCE_ID_AND_PATH[1]> : ParseExternalReferenceSchema<REFERENCING_SCHEMA, OPTIONS, REFERENCE_ID_AND_PATH[0], REFERENCE_ID_AND_PATH[1]>;

package/scripts/node_modules/json-schema-to-ts/lib/types/parse-schema/references/index.js

@@ -1 +0,0 @@
-export {};