eslint-plugin-package-json 0.88.2 → 0.89.0

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.d.mts

@@ -0,0 +1,7 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/deserializationPattern.d.ts
+type DeserializationPattern = Readonly<{
+  pattern: unknown;
+  output: unknown;
+}>;
+//#endregion
+export { DeserializationPattern };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/fromSchemaOptions.d.mts

@@ -0,0 +1,20 @@
+import { DeserializationPattern } from "./deserializationPattern.mjs";
+import { JSONSchemaReference } from "./jsonSchema.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/fromSchemaOptions.d.ts
+type FromSchemaOptions = {
+  parseNotKeyword?: boolean;
+  parseIfThenElseKeywords?: boolean;
+  keepDefaultedPropertiesOptional?: boolean;
+  references?: JSONSchemaReference[] | false;
+  deserialize?: DeserializationPattern[] | false;
+};
+type FromSchemaDefaultOptions = {
+  parseNotKeyword: false;
+  parseIfThenElseKeywords: false;
+  keepDefaultedPropertiesOptional: false;
+  references: false;
+  deserialize: false;
+};
+//#endregion
+export { FromSchemaDefaultOptions, FromSchemaOptions };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.d.mts

@@ -0,0 +1,60 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/definitions/jsonSchema.d.ts
+declare const $JSONSchema: unique symbol;
+type $JSONSchema = typeof $JSONSchema;
+type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+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;
+}>;
+type JSONSchemaReference = JSONSchema & Readonly<{
+  $id: string;
+}>;
+//#endregion
+export { JSONSchema, JSONSchemaReference, JSONSchemaType };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/index.d.mts

@@ -0,0 +1,11 @@
+import { $Resolve } from "../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/resolve.mjs";
+import { DeserializationPattern } from "./definitions/deserializationPattern.mjs";
+import { JSONSchema } from "./definitions/jsonSchema.mjs";
+import { FromSchemaDefaultOptions, FromSchemaOptions } from "./definitions/fromSchemaOptions.mjs";
+import { ParseOptions } from "./parse-options.mjs";
+import { ParseSchema } from "./parse-schema/index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/index.d.ts
+type FromSchema<SCHEMA extends JSONSchema, OPTIONS extends FromSchemaOptions = FromSchemaDefaultOptions> = $Resolve<ParseSchema<SCHEMA, ParseOptions<SCHEMA, OPTIONS>>>;
+//#endregion
+export { FromSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-options.d.mts

@@ -0,0 +1,16 @@
+import { DeserializationPattern } from "./definitions/deserializationPattern.mjs";
+import { JSONSchema, JSONSchemaReference } from "./definitions/jsonSchema.mjs";
+import { FromSchemaDefaultOptions, FromSchemaOptions } from "./definitions/fromSchemaOptions.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-options.d.ts
+type IndexReferencesById<SCHEMA_REFERENCES extends readonly JSONSchemaReference[]> = { [REF_SCHEMA in SCHEMA_REFERENCES[number] as REF_SCHEMA["$id"]]: REF_SCHEMA };
+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"];
+};
+//#endregion
+export { ParseOptions };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/allOf.d.mts

@@ -0,0 +1,13 @@
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { MergeSubSchema } from "./utils.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/allOf.d.ts
+type AllOfSchema = JSONSchema & Readonly<{
+  allOf: readonly JSONSchema[];
+}>;
+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, $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;
+//#endregion
+export { AllOfSchema, ParseAllOfSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/anyOf.d.mts

@@ -0,0 +1,14 @@
+import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { MergeSubSchema } from "./utils.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/anyOf.d.ts
+type AnyOfSchema = JSONSchema & Readonly<{
+  anyOf: readonly JSONSchema[];
+}>;
+type ParseAnyOfSchema<ANY_OF_SCHEMA extends AnyOfSchema, OPTIONS extends ParseSchemaOptions> = $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 | $Intersect<ParseSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, OPTIONS>, ParseSchema<MergeSubSchema<Omit<ROOT_ANY_OF_SCHEMA, "anyOf">, SUB_SCHEMAS_HEAD>, OPTIONS>>> : never : never : RESULT;
+//#endregion
+export { AnyOfSchema, ParseAnyOfSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/array.d.mts

@@ -0,0 +1,58 @@
+import { Never } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.mjs";
+import { $Tuple } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/tuple.mjs";
+import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { _$Array } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/array.mjs";
+import { Any } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/any.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { And } from "../type-utils/and.mjs";
+import { DoesExtend } from "../type-utils/extends.mjs";
+import { Not } from "../type-utils/not.mjs";
+import { Tail } from "../type-utils/tail.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/array.d.ts
+type ArrayOrTupleSchema = JSONSchema & Readonly<{
+  type: "array";
+}>;
+type ArraySchema = Omit<JSONSchema, "items"> & Readonly<{
+  type: "array";
+  items: JSONSchema;
+}>;
+type TupleSchema = JSONSchema & Readonly<{
+  type: "array";
+  items: readonly JSONSchema[];
+}>;
+type ParseArrayOrTupleSchema<ARRAY_OR_TUPLE_SCHEMA extends ArrayOrTupleSchema, OPTIONS extends ParseSchemaOptions> = ARRAY_OR_TUPLE_SCHEMA extends ArraySchema ? _$Array<ParseSchema<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>> : ARRAY_OR_TUPLE_SCHEMA extends TupleSchema ? $Union<ApplyMinMaxAndAdditionalItems<ParseTupleItems<ARRAY_OR_TUPLE_SCHEMA["items"], OPTIONS>, ARRAY_OR_TUPLE_SCHEMA, OPTIONS>> : _$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 ? $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : RESULT | $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 | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : HAS_ENCOUNTERED_MAX extends true ? RESULT | $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : MAX extends RECURSED_PARSED_ITEM_SCHEMAS["length"] ? $Tuple<RECURSED_PARSED_ITEM_SCHEMAS> : IsLongerThan<Tail<RECURSED_PARSED_ITEM_SCHEMAS>, MAX> extends true ? never : RESULT | $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"] : Never : ADDITIONAL_ITEMS_SCHEMA extends false ? APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMin: true;
+} ? APPLY_MIN_MAX_RESULT["result"] : Never : ADDITIONAL_ITEMS_SCHEMA extends true ? APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMin: true;
+} ? APPLY_MIN_MAX_RESULT["result"] | $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], Any> : $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], Any> : APPLY_MIN_MAX_RESULT extends {
+  hasEncounteredMin: true;
+} ? APPLY_MIN_MAX_RESULT["result"] | $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>> : $Tuple<APPLY_MIN_MAX_RESULT["completeTuple"], ParseSchema<ADDITIONAL_ITEMS_SCHEMA, OPTIONS>>;
+//#endregion
+export { ArrayOrTupleSchema, ParseArrayOrTupleSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/const.d.mts

@@ -0,0 +1,14 @@
+import { Const } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/const.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { Writable } from "../type-utils/writable.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/const.d.ts
+type ConstSchema = JSONSchema & Readonly<{
+  const: unknown;
+}>;
+type ParseConstSchema<CONST_SCHEMA extends ConstSchema, OPTIONS extends ParseSchemaOptions> = $Intersect<ParseConst<CONST_SCHEMA>, ParseSchema<Omit<CONST_SCHEMA, "const">, OPTIONS>>;
+type ParseConst<CONST_SCHEMA extends ConstSchema> = Const<Writable<CONST_SCHEMA["const"]>>;
+//#endregion
+export { ConstSchema, ParseConstSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/deserialize.d.mts

@@ -0,0 +1,13 @@
+import { Any } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/any.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { DeserializationPattern } from "../definitions/deserializationPattern.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/deserialize.d.ts
+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 = 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"] ? $Intersect<Any<true, DESERIALIZATION_PATTERNS_HEAD["output"]>, RESULT> : RESULT> : never : never : RESULT;
+//#endregion
+export { DeserializeSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/enum.d.mts

@@ -0,0 +1,14 @@
+import { Enum } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/enum.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { Writable } from "../type-utils/writable.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/enum.d.ts
+type EnumSchema = JSONSchema & Readonly<{
+  enum: readonly unknown[];
+}>;
+type ParseEnumSchema<ENUM_SCHEMA extends EnumSchema, OPTIONS extends ParseSchemaOptions> = $Intersect<ParseEnum<ENUM_SCHEMA>, ParseSchema<Omit<ENUM_SCHEMA, "enum">, OPTIONS>>;
+type ParseEnum<ENUM_SCHEMA extends EnumSchema> = Enum<Writable<ENUM_SCHEMA["enum"][number]>>;
+//#endregion
+export { EnumSchema, ParseEnumSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/ifThenElse.d.mts

@@ -0,0 +1,20 @@
+import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { _$Exclude } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/exclusion/index.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { MergeSubSchema } from "./utils.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/ifThenElse.d.ts
+type IfThenElseSchema = JSONSchema & {
+  if: JSONSchema;
+  then?: JSONSchema;
+  else?: JSONSchema;
+};
+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;
+} ? $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;
+} ? $Intersect<_$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>, ParseSchema<MergeSubSchema<REST_SCHEMA, IF_THEN_ELSE_SCHEMA["else"]>, OPTIONS>> : _$Exclude<ParseSchema<REST_SCHEMA, OPTIONS>, ParseSchema<IF_SCHEMA, OPTIONS>>)> = $Intersect<$Union<PARSED_THEN_SCHEMA | PARSED_ELSE_SCHEMA>, ParseSchema<REST_SCHEMA, OPTIONS>>;
+//#endregion
+export { IfThenElseSchema, ParseIfThenElseSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/index.d.mts

@@ -0,0 +1,34 @@
+import { Never } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.mjs";
+import { Any } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/any.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { DeserializationPattern } from "../definitions/deserializationPattern.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { And } from "../type-utils/and.mjs";
+import { DoesExtend } from "../type-utils/extends.mjs";
+import { AllOfSchema, ParseAllOfSchema } from "./allOf.mjs";
+import { AnyOfSchema, ParseAnyOfSchema } from "./anyOf.mjs";
+import { ConstSchema, ParseConstSchema } from "./const.mjs";
+import { DeserializeSchema } from "./deserialize.mjs";
+import { EnumSchema, ParseEnumSchema } from "./enum.mjs";
+import { IfThenElseSchema, ParseIfThenElseSchema } from "./ifThenElse.mjs";
+import { MultipleTypesSchema, ParseMultipleTypesSchema } from "./multipleTypes.mjs";
+import { NotSchema, ParseNotSchema } from "./not.mjs";
+import { NullableSchema, ParseNullableSchema } from "./nullable.mjs";
+import { OneOfSchema, ParseOneOfSchema } from "./oneOf.mjs";
+import { ParseReferenceSchema, ReferencingSchema } from "./references/index.mjs";
+import { ParseSingleTypeSchema, SingleTypeSchema } from "./singleType.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/index.d.ts
+type ParseSchemaOptions = {
+  parseNotKeyword: boolean;
+  parseIfThenElseKeywords: boolean;
+  keepDefaultedPropertiesOptional: boolean;
+  rootSchema: JSONSchema;
+  references: Record<string, JSONSchema>;
+  deserialize: DeserializationPattern[] | false;
+};
+type ParseSchema<SCHEMA extends JSONSchema, OPTIONS extends ParseSchemaOptions, RESULT = (JSONSchema extends SCHEMA ? Any : SCHEMA extends true | string ? Any : SCHEMA extends false ? 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> : Any)> = OPTIONS extends {
+  deserialize: DeserializationPattern[];
+} ? $Intersect<DeserializeSchema<SCHEMA, OPTIONS>, RESULT> : RESULT;
+//#endregion
+export { ParseSchema, ParseSchemaOptions };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/multipleTypes.d.mts

@@ -0,0 +1,14 @@
+import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { JSONSchema, JSONSchemaType } from "../definitions/jsonSchema.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/multipleTypes.d.ts
+type MultipleTypesSchema = JSONSchema & Readonly<{
+  type: readonly JSONSchemaType[];
+}>;
+type ParseMultipleTypesSchema<MULTI_TYPE_SCHEMA extends MultipleTypesSchema, OPTIONS extends ParseSchemaOptions> = $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;
+//#endregion
+export { MultipleTypesSchema, ParseMultipleTypesSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/not.d.mts

@@ -0,0 +1,20 @@
+import { Never } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.mjs";
+import { _Object } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/object.mjs";
+import { Primitive } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/primitive.mjs";
+import { Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { _Array } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/array.mjs";
+import { Any, AnyType } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/any.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { _$Exclude } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/exclusion/index.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { MergeSubSchema } from "./utils.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/not.d.ts
+type NotSchema = JSONSchema & Readonly<{
+  not: JSONSchema;
+}>;
+type AllTypes = Union<Primitive<null> | Primitive<boolean> | Primitive<number> | Primitive<string> | _Array | _Object<{}, never, Any>>;
+type ParseNotSchema<NOT_SCHEMA extends NotSchema, OPTIONS extends ParseSchemaOptions, PARSED_REST_SCHEMA = ParseSchema<Omit<NOT_SCHEMA, "not">, OPTIONS>, EXCLUSION = _$Exclude<PARSED_REST_SCHEMA extends AnyType ? $Intersect<AllTypes, PARSED_REST_SCHEMA> : PARSED_REST_SCHEMA, ParseSchema<MergeSubSchema<Omit<NOT_SCHEMA, "not">, NOT_SCHEMA["not"]>, OPTIONS>>> = EXCLUSION extends Never ? PARSED_REST_SCHEMA : EXCLUSION;
+//#endregion
+export { NotSchema, ParseNotSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/nullable.d.mts

@@ -0,0 +1,14 @@
+import { Primitive } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/primitive.mjs";
+import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/nullable.d.ts
+type NullableSchema = JSONSchema & Readonly<{
+  nullable: boolean;
+}>;
+type ParseNullableSchema<NULLABLE_SCHEMA extends NullableSchema, OPTIONS extends ParseSchemaOptions, PARSED_REST_SCHEMA = ParseSchema<Omit<NULLABLE_SCHEMA, "nullable">, OPTIONS>> = NULLABLE_SCHEMA extends Readonly<{
+  nullable: true;
+}> ? $Union<Primitive<null> | PARSED_REST_SCHEMA> : PARSED_REST_SCHEMA;
+//#endregion
+export { NullableSchema, ParseNullableSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/object.d.mts

@@ -0,0 +1,34 @@
+import { _$Object } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/object.mjs";
+import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { Any } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/any.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/object.d.ts
+type ObjectSchema = JSONSchema & Readonly<{
+  type: "object";
+}>;
+type ParseObjectSchema<OBJECT_SCHEMA extends ObjectSchema, OPTIONS extends ParseSchemaOptions> = OBJECT_SCHEMA extends Readonly<{
+  properties: Readonly<Record<string, JSONSchema>>;
+}> ? _$Object<{ [KEY in keyof OBJECT_SCHEMA["properties"]]: ParseSchema<OBJECT_SCHEMA["properties"][KEY], OPTIONS> }, GetRequired<OBJECT_SCHEMA, OPTIONS>, GetOpenProps<OBJECT_SCHEMA, OPTIONS>, GetClosedOnResolve<OBJECT_SCHEMA>> : _$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> : 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> = $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> : $Union<ParseSchema<ADDITIONAL_PROPERTIES_SCHEMA, OPTIONS> | { [KEY in keyof PATTERN_PROPERTY_SCHEMAS]: ParseSchema<PATTERN_PROPERTY_SCHEMAS[KEY], OPTIONS> }[keyof PATTERN_PROPERTY_SCHEMAS]>;
+//#endregion
+export { ObjectSchema, ParseObjectSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/oneOf.d.mts

@@ -0,0 +1,14 @@
+import { $Union } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/union.mjs";
+import { $Intersect } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+import { MergeSubSchema } from "./utils.mjs";
+import { ParseSchema, ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/oneOf.d.ts
+type OneOfSchema = JSONSchema & Readonly<{
+  oneOf: readonly JSONSchema[];
+}>;
+type ParseOneOfSchema<ONE_OF_SCHEMA extends OneOfSchema, OPTIONS extends ParseSchemaOptions> = $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 | $Intersect<ParseSchema<Omit<ROOT_ONE_OF_SCHEMA, "oneOf">, OPTIONS>, ParseSchema<MergeSubSchema<Omit<ROOT_ONE_OF_SCHEMA, "oneOf">, SUB_SCHEMAS_HEAD>, OPTIONS>>> : never : never : RESULT;
+//#endregion
+export { OneOfSchema, ParseOneOfSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/external.d.mts

@@ -0,0 +1,22 @@
+import { Never } from "../../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.mjs";
+import { JSONSchema } from "../../definitions/jsonSchema.mjs";
+import { Join } from "../../type-utils/join.mjs";
+import { Pop } from "../../type-utils/pop.mjs";
+import { Split } from "../../type-utils/split.mjs";
+import { ParseReference } from "./utils.mjs";
+import { ReferencingSchema } from "./index.mjs";
+import { ParseSchemaOptions } from "../index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/external.d.ts
+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> : 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> : Never;
+//#endregion
+export { ParseExternalReferenceSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/index.d.mts

@@ -0,0 +1,13 @@
+import { JSONSchema } from "../../definitions/jsonSchema.mjs";
+import { Split } from "../../type-utils/split.mjs";
+import { ParseExternalReferenceSchema } from "./external.mjs";
+import { ParseInternalReferenceSchema } from "./internal.mjs";
+import { ParseSchemaOptions } from "../index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/index.d.ts
+type ReferencingSchema = JSONSchema & {
+  $ref: string;
+};
+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]>;
+//#endregion
+export { ParseReferenceSchema, ReferencingSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/internal.d.mts

@@ -0,0 +1,8 @@
+import { ParseReference } from "./utils.mjs";
+import { ReferencingSchema } from "./index.mjs";
+import { ParseSchemaOptions } from "../index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/internal.d.ts
+type ParseInternalReferenceSchema<REFERENCING_SCHEMA extends ReferencingSchema, OPTIONS extends ParseSchemaOptions, PATH extends string> = ParseReference<Omit<REFERENCING_SCHEMA, "$ref">, OPTIONS, OPTIONS["rootSchema"], PATH>;
+//#endregion
+export { ParseInternalReferenceSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/utils.d.mts

@@ -0,0 +1,12 @@
+import { $Intersect } from "../../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/intersection/index.mjs";
+import { JSONSchema } from "../../definitions/jsonSchema.mjs";
+import { DeepGet } from "../../type-utils/get.mjs";
+import { Split } from "../../type-utils/split.mjs";
+import { Tail } from "../../type-utils/tail.mjs";
+import { MergeSubSchema } from "../utils.mjs";
+import { ParseSchema, ParseSchemaOptions } from "../index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/references/utils.d.ts
+type ParseReference<SCHEMA extends JSONSchema, OPTIONS extends ParseSchemaOptions, REFERENCE_SOURCE extends JSONSchema, PATH_IN_SOURCE extends string | undefined, MATCHING_REFERENCE extends JSONSchema = (PATH_IN_SOURCE extends string ? DeepGet<REFERENCE_SOURCE, Tail<Split<PATH_IN_SOURCE, "/">>, false> : REFERENCE_SOURCE)> = $Intersect<ParseSchema<MATCHING_REFERENCE, OPTIONS>, ParseSchema<MergeSubSchema<MATCHING_REFERENCE, SCHEMA>, OPTIONS>>;
+//#endregion
+export { ParseReference };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/singleType.d.mts

@@ -0,0 +1,24 @@
+import { Never } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/never.mjs";
+import { Primitive } from "../../../../../../ts-algebra@2.0.0/node_modules/ts-algebra/lib/meta-types/primitive.mjs";
+import { JSONSchema, JSONSchemaType } from "../definitions/jsonSchema.mjs";
+import { ArrayOrTupleSchema, ParseArrayOrTupleSchema } from "./array.mjs";
+import { ObjectSchema, ParseObjectSchema } from "./object.mjs";
+import { ParseSchemaOptions } from "./index.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/singleType.d.ts
+type SingleTypeSchema = JSONSchema & Readonly<{
+  type: JSONSchemaType;
+}>;
+type ParseSingleTypeSchema<SINGLE_TYPE_SCHEMA extends SingleTypeSchema, OPTIONS extends ParseSchemaOptions> = SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "null";
+}> ? Primitive<null> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "boolean";
+}> ? Primitive<boolean> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "integer";
+}> ? Primitive<number> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "number";
+}> ? Primitive<number> : SINGLE_TYPE_SCHEMA extends Readonly<{
+  type: "string";
+}> ? Primitive<string> : SINGLE_TYPE_SCHEMA extends ArrayOrTupleSchema ? ParseArrayOrTupleSchema<SINGLE_TYPE_SCHEMA, OPTIONS> : SINGLE_TYPE_SCHEMA extends ObjectSchema ? ParseObjectSchema<SINGLE_TYPE_SCHEMA, OPTIONS> : Never;
+//#endregion
+export { ParseSingleTypeSchema, SingleTypeSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/utils.d.mts

@@ -0,0 +1,20 @@
+import { JSONSchema } from "../definitions/jsonSchema.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/parse-schema/utils.d.ts
+type RemoveInvalidAdditionalItems<SCHEMA extends JSONSchema> = SCHEMA extends Readonly<{
+  items: JSONSchema | readonly JSONSchema[];
+}> ? SCHEMA extends Readonly<{
+  additionalItems: JSONSchema;
+}> ? SCHEMA : SCHEMA & Readonly<{
+  additionalItems: true;
+}> : SCHEMA extends boolean ? SCHEMA : Omit<SCHEMA, "additionalItems">;
+type RemoveInvalidAdditionalProperties<SCHEMA extends JSONSchema> = SCHEMA extends Readonly<{
+  additionalProperties: JSONSchema;
+}> ? SCHEMA extends Readonly<{
+  properties: Readonly<Record<string, JSONSchema>>;
+}> ? SCHEMA : SCHEMA & Readonly<{
+  properties: {};
+}> : SCHEMA extends boolean ? SCHEMA : Omit<SCHEMA, "additionalProperties">;
+type MergeSubSchema<PARENT_SCHEMA extends JSONSchema, SUB_SCHEMA extends JSONSchema, CLEANED_SUB_SCHEMA extends JSONSchema = RemoveInvalidAdditionalProperties<RemoveInvalidAdditionalItems<SUB_SCHEMA>>> = Omit<PARENT_SCHEMA, keyof CLEANED_SUB_SCHEMA | "additionalProperties" | "patternProperties" | "unevaluatedProperties" | "required" | "additionalItems"> & CLEANED_SUB_SCHEMA;
+//#endregion
+export { MergeSubSchema };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/and.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/and.d.ts
+type And<CONDITION_A, CONDITION_B> = CONDITION_A extends true ? CONDITION_B extends true ? true : false : false;
+//#endregion
+export { And };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/extends.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/extends.d.ts
+type DoesExtend<TYPE_A, TYPE_B> = [TYPE_A] extends [TYPE_B] ? true : false;
+//#endregion
+export { DoesExtend };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/get.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/get.d.ts
+type DeepGet<OBJECT, PATH extends string[], DEFAULT = undefined> = PATH extends [infer PATH_HEAD, ...infer PATH_TAIL] ? PATH_HEAD extends string ? PATH_TAIL extends string[] ? PATH_HEAD extends keyof OBJECT ? DeepGet<OBJECT[PATH_HEAD], PATH_TAIL, DEFAULT> : DEFAULT : never : never : OBJECT;
+//#endregion
+export { DeepGet };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/join.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/join.d.ts
+type Join<STRINGS extends string[], SEPARATOR extends string = ","> = STRINGS extends [] ? "" : STRINGS extends [string] ? `${STRINGS[0]}` : STRINGS extends [string, ...infer STRINGS_TAIL] ? STRINGS_TAIL extends string[] ? `${STRINGS[0]}${SEPARATOR}${Join<STRINGS_TAIL, SEPARATOR>}` : never : string;
+//#endregion
+export { Join };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/not.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/not.d.ts
+type Not<BOOL> = BOOL extends false ? true : BOOL extends true ? false : never;
+//#endregion
+export { Not };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/pop.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/pop.d.ts
+type Pop<ARRAY extends unknown[]> = ARRAY extends readonly [...infer ARRAY_BODY, unknown] | readonly [...infer ARRAY_BODY, unknown?] ? ARRAY_BODY : ARRAY;
+//#endregion
+export { Pop };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/split.d.mts

@@ -0,0 +1,7 @@
+import { Pop } from "./pop.mjs";
+
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/split.d.ts
+type RecursiveSplit<STRING extends string, SEPARATOR extends string = ""> = STRING extends `${infer BEFORE}${SEPARATOR}${infer AFTER}` ? [BEFORE, ...RecursiveSplit<AFTER, SEPARATOR>] : [STRING];
+type Split<STRING extends string, SEPARATOR extends string = "", RESULT extends string[] = RecursiveSplit<STRING, SEPARATOR>> = SEPARATOR extends "" ? Pop<RESULT> : RESULT;
+//#endregion
+export { Split };

package/lib/node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/tail.d.mts

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/json-schema-to-ts@3.1.1/node_modules/json-schema-to-ts/lib/types/type-utils/tail.d.ts
+type Tail<ARRAY extends unknown[]> = ARRAY extends readonly [] ? ARRAY : ARRAY extends readonly [unknown?, ...infer ARRAY_TAIL] ? ARRAY_TAIL : ARRAY;
+//#endregion
+export { Tail };