json-schema-to-ts - npm Package Compare versions

Comparing version 2.8.2 to 2.9.0

lib/types/definitions/deserializationPattern.d.ts

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

lib/types/definitions/extendedJsonSchema7.d.ts

 import type { JSONSchema7 as OriginalJSONSchema7 } from "json-schema";
 import { $JSONSchema7 } from "./jsonSchema7";
-export declare type JSONSchema7Extension = Record<string, unknown>;
-export declare type ExtendedJSONSchema7<E extends JSONSchema7Extension = JSONSchema7Extension> = boolean | (Omit<OriginalJSONSchema7, "const" | "enum" | "items" | "additionalItems" | "contains" | "properties" | "patternProperties" | "additionalProperties" | "dependencies" | "propertyNames" | "if" | "then" | "else" | "allOf" | "anyOf" | "oneOf" | "not" | "definitions" | "examples" | "default"> & {
+export type JSONSchema7Extension = Record<string, unknown>;
+export type ExtendedJSONSchema7<E extends JSONSchema7Extension = JSONSchema7Extension> = boolean | (Omit<OriginalJSONSchema7, "const" | "enum" | "items" | "additionalItems" | "contains" | "properties" | "patternProperties" | "additionalProperties" | "dependencies" | "propertyNames" | "if" | "then" | "else" | "allOf" | "anyOf" | "oneOf" | "not" | "definitions" | "examples" | "default"> & {
     const?: unknown;
@@ -31,10 +31,10 @@ enum?: unknown;
 } & Partial<E>);
-export declare type ExtendedJSONSchema7Reference<E extends JSONSchema7Extension = JSONSchema7Extension> = ExtendedJSONSchema7<E> & {
+export type ExtendedJSONSchema7Reference<E extends JSONSchema7Extension = JSONSchema7Extension> = ExtendedJSONSchema7<E> & {
     $id: string;
 };
-declare type UnextendJSONSchema7Tuple<E extends JSONSchema7Extension, S extends ExtendedJSONSchema7<E>[]> = S extends [infer H, ...infer T] ? H extends ExtendedJSONSchema7<E> ? T extends ExtendedJSONSchema7<E>[] ? [UnextendJSONSchema7<E, H>, ...UnextendJSONSchema7Tuple<E, T>] : never : never : [];
-declare type UnextendJSONSchema7Record<E extends JSONSchema7Extension, S extends Record<string, unknown>> = {
+type UnextendJSONSchema7Tuple<E extends JSONSchema7Extension, S extends ExtendedJSONSchema7<E>[]> = S extends [infer H, ...infer T] ? H extends ExtendedJSONSchema7<E> ? T extends ExtendedJSONSchema7<E>[] ? [UnextendJSONSchema7<E, H>, ...UnextendJSONSchema7Tuple<E, T>] : never : never : [];
+type UnextendJSONSchema7Record<E extends JSONSchema7Extension, S extends Record<string, unknown>> = {
     [key in keyof S]: S[key] extends ExtendedJSONSchema7<E> ? UnextendJSONSchema7<E, S[key]> : S[key];
 };
-export declare type UnextendJSONSchema7<E extends JSONSchema7Extension, S> = S extends boolean ? S : {
+export type UnextendJSONSchema7<E extends JSONSchema7Extension, S> = S extends boolean ? S : {
     [key in $JSONSchema7 | keyof S]: key extends keyof S ? S extends {
@@ -41,0 +41,0 @@ [k in key]: ExtendedJSONSchema7<E>;

lib/types/definitions/fromSchemaOptions.d.ts

@@ -1,5 +0,5 @@
-import type { JSONSchema7Reference } from "../index";
+import type { JSONSchema7Reference } from "~/index";
 import type { DeserializationPattern } from "./deserializationPattern";
 import type { JSONSchema7Extension, ExtendedJSONSchema7Reference } from "./extendedJsonSchema7";
-export declare type FromSchemaOptions = {
+export type FromSchemaOptions = {
     parseNotKeyword?: boolean;
@@ -10,3 +10,3 @@ parseIfThenElseKeywords?: boolean;
 };
-export declare type FromExtendedSchemaOptions<E extends JSONSchema7Extension> = {
+export type FromExtendedSchemaOptions<E extends JSONSchema7Extension> = {
     parseNotKeyword?: boolean;
@@ -17,3 +17,3 @@ parseIfThenElseKeywords?: boolean;
 };
-export declare type FromSchemaDefaultOptions = {
+export type FromSchemaDefaultOptions = {
     parseNotKeyword: false;
@@ -20,0 +20,0 @@ parseIfThenElseKeywords: false;

lib/types/definitions/jsonSchema7.d.ts

 import type { JSONSchema7 as OriginalJSONSchema7 } from "json-schema";
 export declare const $JSONSchema7: unique symbol;
-export declare type $JSONSchema7 = typeof $JSONSchema7;
-export declare type JSONSchema7 = boolean | (Omit<OriginalJSONSchema7, "const" | "enum" | "items" | "additionalItems" | "contains" | "properties" | "patternProperties" | "additionalProperties" | "dependencies" | "propertyNames" | "if" | "then" | "else" | "allOf" | "anyOf" | "oneOf" | "not" | "definitions" | "examples" | "default"> & {
+export type $JSONSchema7 = typeof $JSONSchema7;
+export type JSONSchema7 = boolean | (Omit<OriginalJSONSchema7, "const" | "enum" | "items" | "additionalItems" | "contains" | "properties" | "patternProperties" | "additionalProperties" | "dependencies" | "propertyNames" | "if" | "then" | "else" | "allOf" | "anyOf" | "oneOf" | "not" | "definitions" | "examples" | "default"> & {
     [$JSONSchema7]?: $JSONSchema7;
@@ -32,4 +32,4 @@ const?: unknown;
 });
-export declare type JSONSchema7Reference = JSONSchema7 & {
+export type JSONSchema7Reference = JSONSchema7 & {
     $id: string;
 };

lib/types/index.d.ts

@@ -9,9 +9,9 @@ import type { M } from "ts-algebra";
 export { wrapCompilerAsTypeGuard, wrapValidatorAsTypeGuard, asConst, } from "./utils";
-export declare type JSONSchema7 = $JSONSchema7 | Readonly<$JSONSchema7>;
-export declare type ExtendedJSONSchema7<E extends JSONSchema7Extension> = $ExtendedJSONSchema7<E> | Readonly<$ExtendedJSONSchema7<E>>;
-export declare type JSONSchema7Reference = $JSONSchema7Reference | Readonly<$JSONSchema7Reference>;
-export declare type ExtendedJSONSchema7Reference<E extends JSONSchema7Extension> = $ExtendedJSONSchema7Reference<E> | Readonly<$ExtendedJSONSchema7Reference<E>>;
-export declare type JSONSchema = JSONSchema7;
-export declare type ExtendedJSONSchema<E extends JSONSchema7Extension> = ExtendedJSONSchema7<E>;
-export declare type FromSchema<S extends JSONSchema, Opt extends FromSchemaOptions = FromSchemaDefaultOptions, W extends $JSONSchema7 = S extends Record<string | number | symbol, unknown> ? Writable<S> : S> = M.$Resolve<ParseSchema<W, ParseOptions<W, Opt>>>;
-export declare type FromExtendedSchema<E extends JSONSchema7Extension, S extends ExtendedJSONSchema<E>, Opt extends FromExtendedSchemaOptions<E> = FromSchemaDefaultOptions, U = UnextendJSONSchema7<E, S>> = U extends JSONSchema ? FromSchema<U, Opt> : never;
+export type JSONSchema7 = $JSONSchema7 | Readonly<$JSONSchema7>;
+export type ExtendedJSONSchema7<E extends JSONSchema7Extension> = $ExtendedJSONSchema7<E> | Readonly<$ExtendedJSONSchema7<E>>;
+export type JSONSchema7Reference = $JSONSchema7Reference | Readonly<$JSONSchema7Reference>;
+export type ExtendedJSONSchema7Reference<E extends JSONSchema7Extension> = $ExtendedJSONSchema7Reference<E> | Readonly<$ExtendedJSONSchema7Reference<E>>;
+export type JSONSchema = JSONSchema7;
+export type ExtendedJSONSchema<E extends JSONSchema7Extension> = ExtendedJSONSchema7<E>;
+export type FromSchema<S extends JSONSchema, Opt extends FromSchemaOptions = FromSchemaDefaultOptions, W extends $JSONSchema7 = S extends Record<string | number | symbol, unknown> ? Writable<S> : S> = M.$Resolve<ParseSchema<W, ParseOptions<W, Opt>>>;
+export type FromExtendedSchema<E extends JSONSchema7Extension, S extends ExtendedJSONSchema<E>, Opt extends FromExtendedSchemaOptions<E> = FromSchemaDefaultOptions, U = UnextendJSONSchema7<E, S>> = U extends JSONSchema ? FromSchema<U, Opt> : never;

lib/types/parse-options.d.ts

 import type { JSONSchema7, FromSchemaOptions, FromSchemaDefaultOptions, DeserializationPattern } from "./definitions";
 import type { JSONSchema7Reference } from "./index";
 import type { Writable } from "./type-utils";
-export declare type ParseReferences<S extends JSONSchema7Reference[], R extends Record<string, JSONSchema7> = {}> = S extends [infer H, ...infer T] ? H extends JSONSchema7Reference ? T extends JSONSchema7Reference[] ? ParseReferences<T, R & {
+export type ParseReferences<S extends JSONSchema7Reference[], R extends Record<string, JSONSchema7> = {}> = S extends [infer H, ...infer T] ? H extends JSONSchema7Reference ? T extends JSONSchema7Reference[] ? ParseReferences<T, R & {
     [key in H["$id"]]: Writable<H>;
 }> : never : never : R;
-export declare type ParseOptions<S extends JSONSchema7, O extends FromSchemaOptions> = {
+export type ParseOptions<S extends JSONSchema7, O extends FromSchemaOptions> = {
     parseNotKeyword: O["parseNotKeyword"] extends boolean ? O["parseNotKeyword"] : FromSchemaDefaultOptions["parseNotKeyword"];
@@ -9,0 +9,0 @@ parseIfThenElseKeywords: O["parseIfThenElseKeywords"] extends boolean ? O["parseIfThenElseKeywords"] : FromSchemaDefaultOptions["parseIfThenElseKeywords"];

lib/types/parse-schema/allOf.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
 import type { MergeSubSchema } from "./utils";
-export declare type AllOfSchema = JSONSchema7 & {
+export type AllOfSchema = JSONSchema7 & {
     allOf: JSONSchema7[];
 };
-export declare type ParseAllOfSchema<P extends AllOfSchema, O extends ParseSchemaOptions> = RecurseOnAllOfSchema<P["allOf"], P, O, ParseSchema<Omit<P, "allOf">, O>>;
-declare type RecurseOnAllOfSchema<S extends JSONSchema7[], P extends AllOfSchema, O extends ParseSchemaOptions, R> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? RecurseOnAllOfSchema<T, P, O, M.$Intersect<ParseSchema<MergeSubSchema<Omit<P, "allOf">, H>, O>, R>> : never : never : R;
+export type ParseAllOfSchema<P extends AllOfSchema, O extends ParseSchemaOptions> = RecurseOnAllOfSchema<P["allOf"], P, O, ParseSchema<Omit<P, "allOf">, O>>;
+type RecurseOnAllOfSchema<S extends JSONSchema7[], P extends AllOfSchema, O extends ParseSchemaOptions, R> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? RecurseOnAllOfSchema<T, P, O, M.$Intersect<ParseSchema<MergeSubSchema<Omit<P, "allOf">, H>, O>, R>> : never : never : R;
 export {};

lib/types/parse-schema/anyOf.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
 import type { MergeSubSchema } from "./utils";
-export declare type AnyOfSchema = JSONSchema7 & {
+export type AnyOfSchema = JSONSchema7 & {
     anyOf: JSONSchema7[];
 };
-export declare type ParseAnyOfSchema<S extends AnyOfSchema, O extends ParseSchemaOptions> = M.$Union<RecurseOnAnyOfSchema<S["anyOf"], S, O>>;
-declare type RecurseOnAnyOfSchema<S extends JSONSchema7[], P extends AnyOfSchema, O extends ParseSchemaOptions, R = never> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? RecurseOnAnyOfSchema<T, P, O, R | M.$Intersect<ParseSchema<Omit<P, "anyOf">, O>, ParseSchema<MergeSubSchema<Omit<P, "anyOf">, H>, O>>> : never : never : R;
+export type ParseAnyOfSchema<S extends AnyOfSchema, O extends ParseSchemaOptions> = M.$Union<RecurseOnAnyOfSchema<S["anyOf"], S, O>>;
+type RecurseOnAnyOfSchema<S extends JSONSchema7[], P extends AnyOfSchema, O extends ParseSchemaOptions, R = never> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? RecurseOnAnyOfSchema<T, P, O, R | M.$Intersect<ParseSchema<Omit<P, "anyOf">, O>, ParseSchema<MergeSubSchema<Omit<P, "anyOf">, H>, O>>> : never : never : R;
 export {};

lib/types/parse-schema/array.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
-import type { DoesExtend, Reverse, Tail } from "../type-utils";
+import type { JSONSchema7 } from "~/definitions";
+import type { DoesExtend, Reverse, Tail } from "~/type-utils";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
-export declare type ArraySchema = JSONSchema7 & {
+export type ArraySchema = JSONSchema7 & {
     type: "array";
 };
-declare type SimpleArraySchema = JSONSchema7 & {
+type SimpleArraySchema = JSONSchema7 & {
     type: "array";
     items: JSONSchema7;
 };
-declare type TupleSchema = JSONSchema7 & {
+type TupleSchema = JSONSchema7 & {
     type: "array";
     items: JSONSchema7[];
 };
-export declare type ParseArraySchema<S extends ArraySchema, O extends ParseSchemaOptions> = S extends SimpleArraySchema ? M.$Array<ParseSchema<S["items"], O>> : S extends TupleSchema ? M.$Union<FromTreeTuple<ParseTuple<S["items"], O>, S, O>> : M.$Array;
-declare type ParseTuple<S extends JSONSchema7[], O extends ParseSchemaOptions> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? [...ParseTuple<T, O>, ParseSchema<H, O>] : never : never : [];
-declare type FromTreeTuple<T extends any[], S extends ArraySchema, O extends ParseSchemaOptions> = ApplyAdditionalItems<ApplyBoundaries<T, S extends {
+export type ParseArraySchema<S extends ArraySchema, O extends ParseSchemaOptions> = S extends SimpleArraySchema ? M.$Array<ParseSchema<S["items"], O>> : S extends TupleSchema ? M.$Union<FromTreeTuple<ParseTuple<S["items"], O>, S, O>> : M.$Array;
+type ParseTuple<S extends JSONSchema7[], O extends ParseSchemaOptions> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? [...ParseTuple<T, O>, ParseSchema<H, O>] : never : never : [];
+type FromTreeTuple<T extends any[], S extends ArraySchema, O extends ParseSchemaOptions> = ApplyAdditionalItems<ApplyBoundaries<T, S extends {
     minItems: number;
@@ -25,3 +25,3 @@ } ? S["minItems"] : 0, S extends {
 } ? S["additionalItems"] : true, O>;
-declare type ApplyBoundaries<T extends any[], Min extends number, Max extends number | undefined, R = never, HasMin extends boolean = false, HasMax extends boolean = false, C extends any[] = T> = {
+type ApplyBoundaries<T extends any[], Min extends number, Max extends number | undefined, R = never, HasMin extends boolean = false, HasMax extends boolean = false, C extends any[] = T> = {
     stop: {
@@ -35,7 +35,7 @@ result: Max extends undefined ? R | M.$Tuple<Reverse<T>> : HasMax extends true ? R | M.$Tuple<Reverse<T>> : Max extends T["length"] ? M.$Tuple<Reverse<T>> : IsLongerThan<Tail<T>, Max> extends true ? never : R | M.$Tuple<Reverse<T>>;
 }[Min extends T["length"] ? "stop" : T extends [any, ...any[]] ? "continue" : "stop"];
-declare type IsLongerThan<T extends any[], N extends number | undefined, R extends boolean = false> = {
+type IsLongerThan<T extends any[], N extends number | undefined, R extends boolean = false> = {
     continue: N extends undefined ? false : T["length"] extends N ? true : IsLongerThan<Tail<T>, N>;
     stop: T["length"] extends N ? true : R;
 }[T extends [any, ...any[]] ? "continue" : "stop"];
-declare type ApplyAdditionalItems<R extends {
+type ApplyAdditionalItems<R extends {
     result: any;
@@ -42,0 +42,0 @@ hasEncounteredMin: boolean;

lib/types/parse-schema/const.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
 import type { MultipleTypesSchema } from "./multipleTypes";
 import type { SingleTypeSchema } from "./singleType";
-export declare type ConstSchema = JSONSchema7 & {
+export type ConstSchema = JSONSchema7 & {
     const: unknown;
 };
-export declare type ParseConstSchema<S extends ConstSchema, O extends ParseSchemaOptions> = S extends SingleTypeSchema ? IntersectConstAndTypeSchema<S, O> : S extends MultipleTypesSchema ? IntersectConstAndTypeSchema<S, O> : ParseConst<S>;
-declare type IntersectConstAndTypeSchema<S extends ConstSchema & (SingleTypeSchema | MultipleTypesSchema), O extends ParseSchemaOptions> = M.$Intersect<ParseConst<S>, ParseSchema<Omit<S, "const">, O>>;
-declare type ParseConst<S extends ConstSchema> = M.Const<S["const"]>;
+export type ParseConstSchema<S extends ConstSchema, O extends ParseSchemaOptions> = S extends SingleTypeSchema ? IntersectConstAndTypeSchema<S, O> : S extends MultipleTypesSchema ? IntersectConstAndTypeSchema<S, O> : ParseConst<S>;
+type IntersectConstAndTypeSchema<S extends ConstSchema & (SingleTypeSchema | MultipleTypesSchema), O extends ParseSchemaOptions> = M.$Intersect<ParseConst<S>, ParseSchema<Omit<S, "const">, O>>;
+type ParseConst<S extends ConstSchema> = M.Const<S["const"]>;
 export {};

lib/types/parse-schema/deserialize.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7, DeserializationPattern } from "../definitions";
+import type { JSONSchema7, DeserializationPattern } from "~/definitions";
 import type { ParseSchemaOptions } from "./index";
-export declare type DeserializeSchema<S extends JSONSchema7, O extends Omit<ParseSchemaOptions, "deserialize"> & {
+export type DeserializeSchema<S extends JSONSchema7, O extends Omit<ParseSchemaOptions, "deserialize"> & {
     deserialize: DeserializationPattern[];
 }> = RecurseOnDeserializationPatterns<S, O["deserialize"]>;
-declare type RecurseOnDeserializationPatterns<S extends JSONSchema7, P extends DeserializationPattern[], R = M.Any> = P extends [infer H, ...infer T] ? H extends DeserializationPattern ? T extends DeserializationPattern[] ? RecurseOnDeserializationPatterns<S, T, S extends H["pattern"] ? M.$Intersect<M.Any<true, H["output"]>, R> : R> : never : never : R;
+type RecurseOnDeserializationPatterns<S extends JSONSchema7, P extends DeserializationPattern[], R = M.Any> = P extends [infer H, ...infer T] ? H extends DeserializationPattern ? T extends DeserializationPattern[] ? RecurseOnDeserializationPatterns<S, T, S extends H["pattern"] ? M.$Intersect<M.Any<true, H["output"]>, R> : R> : never : never : R;
 export {};

lib/types/parse-schema/enum.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
-import type { Compute } from "../type-utils";
+import type { JSONSchema7 } from "~/definitions";
+import type { Compute } from "~/type-utils";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
-export declare type EnumSchema = JSONSchema7 & {
+export type EnumSchema = JSONSchema7 & {
     enum: unknown[];
 };
-export declare type ParseEnumSchema<S extends EnumSchema, O extends ParseSchemaOptions> = M.$Intersect<ParseEnum<S>, ParseSchema<Omit<S, "enum">, O>>;
-declare type ParseEnum<S extends EnumSchema> = M.Enum<Compute<S["enum"][number]>>;
+export type ParseEnumSchema<S extends EnumSchema, O extends ParseSchemaOptions> = M.$Intersect<ParseEnum<S>, ParseSchema<Omit<S, "enum">, O>>;
+type ParseEnum<S extends EnumSchema> = M.Enum<Compute<S["enum"][number]>>;
 export {};

lib/types/parse-schema/ifThenElse.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
 import type { MergeSubSchema } from "./utils";
-export declare type IfThenElseSchema = JSONSchema7 & {
+export type IfThenElseSchema = JSONSchema7 & {
     if: JSONSchema7;
@@ -10,3 +10,3 @@ then?: JSONSchema7;
 };
-export declare type ParseIfThenElseSchema<S extends IfThenElseSchema, O extends ParseSchemaOptions, R extends JSONSchema7 = Omit<S, "if" | "then" | "else">, I extends JSONSchema7 = MergeSubSchema<R, S["if"]>, T = S extends {
+export type ParseIfThenElseSchema<S extends IfThenElseSchema, O extends ParseSchemaOptions, R extends JSONSchema7 = Omit<S, "if" | "then" | "else">, I extends JSONSchema7 = MergeSubSchema<R, S["if"]>, T = S extends {
     then: JSONSchema7;
@@ -13,0 +13,0 @@ } ? M.$Intersect<ParseSchema<I, O>, ParseSchema<MergeSubSchema<R, S["then"]>, O>> : ParseSchema<I, O>, E = S extends {

lib/types/parse-schema/index.d.ts

 import type { M } from "ts-algebra";
-import type { DeserializationPattern, JSONSchema7 } from "../definitions";
-import type { And, DoesExtend } from "../type-utils";
+import type { DeserializationPattern, JSONSchema7 } from "~/definitions";
+import type { And, DoesExtend } from "~/type-utils";
 import type { AllOfSchema, ParseAllOfSchema } from "./allOf";
@@ -16,3 +16,3 @@ import type { AnyOfSchema, ParseAnyOfSchema } from "./anyOf";
 import type { ParseSingleTypeSchema, SingleTypeSchema } from "./singleType";
-export declare type ParseSchemaOptions = {
+export type ParseSchemaOptions = {
     parseNotKeyword: boolean;
@@ -24,4 +24,4 @@ parseIfThenElseKeywords: boolean;
 };
-export declare type ParseSchema<S extends JSONSchema7, O extends ParseSchemaOptions, P = JSONSchema7 extends S ? M.Any : S extends true | string ? M.Any : S extends false ? M.Never : S extends NullableSchema ? ParseNullableSchema<S, O> : S extends ReferenceSchema ? ParseReferenceSchema<S, O> : And<DoesExtend<O["parseIfThenElseKeywords"], true>, DoesExtend<S, IfThenElseSchema>> extends true ? S extends IfThenElseSchema ? ParseIfThenElseSchema<S, O> : never : And<DoesExtend<O["parseNotKeyword"], true>, DoesExtend<S, NotSchema>> extends true ? S extends NotSchema ? ParseNotSchema<S, O> : never : S extends AllOfSchema ? ParseAllOfSchema<S, O> : S extends OneOfSchema ? ParseOneOfSchema<S, O> : S extends AnyOfSchema ? ParseAnyOfSchema<S, O> : S extends EnumSchema ? ParseEnumSchema<S, O> : S extends ConstSchema ? ParseConstSchema<S, O> : S extends MultipleTypesSchema ? ParseMultipleTypesSchema<S, O> : S extends SingleTypeSchema ? ParseSingleTypeSchema<S, O> : M.Any> = O extends {
+export type ParseSchema<S extends JSONSchema7, O extends ParseSchemaOptions, P = JSONSchema7 extends S ? M.Any : S extends true | string ? M.Any : S extends false ? M.Never : S extends NullableSchema ? ParseNullableSchema<S, O> : S extends ReferenceSchema ? ParseReferenceSchema<S, O> : And<DoesExtend<O["parseIfThenElseKeywords"], true>, DoesExtend<S, IfThenElseSchema>> extends true ? S extends IfThenElseSchema ? ParseIfThenElseSchema<S, O> : never : And<DoesExtend<O["parseNotKeyword"], true>, DoesExtend<S, NotSchema>> extends true ? S extends NotSchema ? ParseNotSchema<S, O> : never : S extends AllOfSchema ? ParseAllOfSchema<S, O> : S extends OneOfSchema ? ParseOneOfSchema<S, O> : S extends AnyOfSchema ? ParseAnyOfSchema<S, O> : S extends EnumSchema ? ParseEnumSchema<S, O> : S extends ConstSchema ? ParseConstSchema<S, O> : S extends MultipleTypesSchema ? ParseMultipleTypesSchema<S, O> : S extends SingleTypeSchema ? ParseSingleTypeSchema<S, O> : M.Any> = O extends {
     deserialize: DeserializationPattern[];
 } ? M.$Intersect<DeserializeSchema<S, O>, P> : P;

lib/types/parse-schema/multipleTypes.d.ts

 import type { JSONSchema7TypeName } from "json-schema";
 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
-export declare type MultipleTypesSchema = JSONSchema7 & {
+export type MultipleTypesSchema = JSONSchema7 & {
     type: JSONSchema7TypeName[];
 };
-export declare type ParseMultipleTypesSchema<P extends MultipleTypesSchema, O extends ParseSchemaOptions> = M.$Union<RecurseOnMixedSchema<P["type"], P, O>>;
-declare type RecurseOnMixedSchema<S extends JSONSchema7TypeName[], P extends MultipleTypesSchema, O extends ParseSchemaOptions, R = never> = S extends [infer H, ...infer T] ? H extends JSONSchema7TypeName ? T extends JSONSchema7TypeName[] ? RecurseOnMixedSchema<T, P, O, R | ParseSchema<Omit<P, "type"> & {
+export type ParseMultipleTypesSchema<P extends MultipleTypesSchema, O extends ParseSchemaOptions> = M.$Union<RecurseOnMixedSchema<P["type"], P, O>>;
+type RecurseOnMixedSchema<S extends JSONSchema7TypeName[], P extends MultipleTypesSchema, O extends ParseSchemaOptions, R = never> = S extends [infer H, ...infer T] ? H extends JSONSchema7TypeName ? T extends JSONSchema7TypeName[] ? RecurseOnMixedSchema<T, P, O, R | ParseSchema<Omit<P, "type"> & {
     type: H;
 }, O>> : never : never : R;
 export {};

lib/types/parse-schema/not.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
 import type { MergeSubSchema } from "./utils";
-export declare type NotSchema = JSONSchema7 & {
+export type NotSchema = JSONSchema7 & {
     not: JSONSchema7;
 };
-declare type AllTypes = M.Union<M.Primitive<null> | M.Primitive<boolean> | M.Primitive<number> | M.Primitive<string> | M.Array | M.Object<{}, never, M.Any>>;
-export declare type ParseNotSchema<S extends NotSchema, O extends ParseSchemaOptions, P = ParseSchema<Omit<S, "not">, O>, E = M.$Exclude<P extends M.AnyType ? M.$Intersect<AllTypes, P> : P, ParseSchema<MergeSubSchema<Omit<S, "not">, S["not"]>, O>>> = E extends M.Never ? P : E;
+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<S extends NotSchema, O extends ParseSchemaOptions, P = ParseSchema<Omit<S, "not">, O>, E = M.$Exclude<P extends M.AnyType ? M.$Intersect<AllTypes, P> : P, ParseSchema<MergeSubSchema<Omit<S, "not">, S["not"]>, O>>> = E extends M.Never ? P : E;
 export {};

lib/types/parse-schema/nullable.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
-export declare type NullableSchema = JSONSchema7 & {
+export type NullableSchema = JSONSchema7 & {
     nullable: boolean;
 };
-export declare type ParseNullableSchema<S extends NullableSchema, O extends ParseSchemaOptions, R = ParseSchema<Omit<S, "nullable">, O>> = S extends {
+export type ParseNullableSchema<S extends NullableSchema, O extends ParseSchemaOptions, R = ParseSchema<Omit<S, "nullable">, O>> = S extends {
     nullable: true;
 } ? M.$Union<M.Primitive<null> | R> : R;

lib/types/parse-schema/object.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
-export declare type ObjectSchema = JSONSchema7 & {
+export type ObjectSchema = JSONSchema7 & {
     type: "object";
 };
-export declare type ParseObjectSchema<S extends ObjectSchema, O extends ParseSchemaOptions> = S extends {
+export type ParseObjectSchema<S extends ObjectSchema, O extends ParseSchemaOptions> = S extends {
     properties: Record<string, JSONSchema7>;
@@ -12,6 +12,6 @@ } ? M.$Object<{
 }, GetRequired<S>, GetOpenProps<S, O>> : M.$Object<{}, GetRequired<S>, GetOpenProps<S, O>>;
-declare type GetRequired<S extends ObjectSchema> = S extends {
+type GetRequired<S extends ObjectSchema> = S extends {
     required: ReadonlyArray<string>;
 } ? S["required"][number] : never;
-declare type GetOpenProps<S extends ObjectSchema, O extends ParseSchemaOptions> = S extends {
+type GetOpenProps<S extends ObjectSchema, O extends ParseSchemaOptions> = S extends {
     additionalProperties: JSONSchema7;
@@ -23,8 +23,8 @@ } ? S extends {
 } ? PatternProps<S["patternProperties"], O> : M.Any;
-declare type PatternProps<P extends Record<string, JSONSchema7>, O extends ParseSchemaOptions> = M.$Union<{
+type PatternProps<P extends Record<string, JSONSchema7>, O extends ParseSchemaOptions> = M.$Union<{
     [key in keyof P]: ParseSchema<P[key], O>;
 }[keyof P]>;
-declare type AdditionalAndPatternProps<A extends JSONSchema7, P extends Record<string, JSONSchema7>, O extends ParseSchemaOptions> = A extends boolean ? PatternProps<P, O> : M.$Union<ParseSchema<A, O> | {
+type AdditionalAndPatternProps<A extends JSONSchema7, P extends Record<string, JSONSchema7>, O extends ParseSchemaOptions> = A extends boolean ? PatternProps<P, O> : M.$Union<ParseSchema<A, O> | {
     [key in keyof P]: ParseSchema<P[key], O>;
 }[keyof P]>;
 export {};

lib/types/parse-schema/oneOf.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseSchema, ParseSchemaOptions } from "./index";
 import type { MergeSubSchema } from "./utils";
-export declare type OneOfSchema = JSONSchema7 & {
+export type OneOfSchema = JSONSchema7 & {
     oneOf: JSONSchema7[];
 };
-export declare type ParseOneOfSchema<P extends OneOfSchema, O extends ParseSchemaOptions> = M.$Union<RecurseOnOneOfSchema<P["oneOf"], P, O>>;
-declare type RecurseOnOneOfSchema<S extends JSONSchema7[], P extends OneOfSchema, O extends ParseSchemaOptions, R = never> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? RecurseOnOneOfSchema<T, P, O, R | M.$Intersect<ParseSchema<Omit<P, "oneOf">, O>, ParseSchema<MergeSubSchema<Omit<P, "oneOf">, H>, O>>> : never : never : R;
+export type ParseOneOfSchema<P extends OneOfSchema, O extends ParseSchemaOptions> = M.$Union<RecurseOnOneOfSchema<P["oneOf"], P, O>>;
+type RecurseOnOneOfSchema<S extends JSONSchema7[], P extends OneOfSchema, O extends ParseSchemaOptions, R = never> = S extends [infer H, ...infer T] ? H extends JSONSchema7 ? T extends JSONSchema7[] ? RecurseOnOneOfSchema<T, P, O, R | M.$Intersect<ParseSchema<Omit<P, "oneOf">, O>, ParseSchema<MergeSubSchema<Omit<P, "oneOf">, H>, O>>> : never : never : R;
 export {};

lib/types/parse-schema/references/definitions.d.ts

 import type { ParseSchemaOptions } from "../index";
 import type { ReferenceSchema } from "./index";
 import type { ParseReference } from "./utils";
-export declare type ParseDefinitionSchema<S extends ReferenceSchema, O extends ParseSchemaOptions, P extends string> = ParseReference<O["rootSchema"], O, P, Omit<S, "$ref">>;
+export type ParseDefinitionSchema<S extends ReferenceSchema, O extends ParseSchemaOptions, P extends string> = ParseReference<O["rootSchema"], O, P, Omit<S, "$ref">>;

lib/types/parse-schema/references/index.d.ts

@@ -1,9 +0,9 @@
-import type { JSONSchema7 } from "../../definitions";
-import type { Split } from "../../type-utils/split";
+import type { JSONSchema7 } from "~/definitions";
+import type { Split } from "~/type-utils/split";
 import type { ParseSchemaOptions } from "../index";
 import type { ParseDefinitionSchema } from "./definitions";
 import type { ParseExternalReferenceSchema } from "./references";
-export declare type ReferenceSchema = JSONSchema7 & {
+export type ReferenceSchema = JSONSchema7 & {
     $ref: string;
 };
-export declare type ParseReferenceSchema<Sc extends ReferenceSchema, O extends ParseSchemaOptions, R extends string[] = Split<Sc["$ref"], "#">> = R[0] extends "" ? ParseDefinitionSchema<Sc, O, R[1]> : ParseExternalReferenceSchema<Sc, O, R[0], R[1]>;
+export type ParseReferenceSchema<Sc extends ReferenceSchema, O extends ParseSchemaOptions, R extends string[] = Split<Sc["$ref"], "#">> = R[0] extends "" ? ParseDefinitionSchema<Sc, O, R[1]> : ParseExternalReferenceSchema<Sc, O, R[0], R[1]>;

lib/types/parse-schema/references/references.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../../definitions";
-import type { Join, Pop, Split } from "../../type-utils";
+import type { JSONSchema7 } from "~/definitions";
+import type { Join, Pop, Split } from "~/type-utils";
 import type { ParseSchemaOptions } from "../index";
 import type { ReferenceSchema } from "./index";
 import type { ParseReference } from "./utils";
-export declare type ParseExternalReferenceSchema<Sc extends ReferenceSchema, O extends ParseSchemaOptions, A extends string, P extends string | undefined, R extends JSONSchema7 = Omit<Sc, "$ref">> = A extends keyof O["references"] ? ParseReference<O["references"][A], O, P, R> : O extends {
+export type ParseExternalReferenceSchema<Sc extends ReferenceSchema, O extends ParseSchemaOptions, A extends string, P extends string | undefined, R extends JSONSchema7 = Omit<Sc, "$ref">> = A extends keyof O["references"] ? ParseReference<O["references"][A], O, P, R> : O extends {
     rootSchema: IdSchema;
 } ? ParseExternalReferenceWithIdSchema<O, A, P, R> : M.Never;
-declare type ParseDomain<R extends string> = Join<Pop<Split<R, "/">>, "/">;
-declare type IdSchema = JSONSchema7 & {
+type ParseDomain<R extends string> = Join<Pop<Split<R, "/">>, "/">;
+type IdSchema = JSONSchema7 & {
     $id: string;
 };
-declare type ParseExternalReferenceWithIdSchema<O extends ParseSchemaOptions & {
+type ParseExternalReferenceWithIdSchema<O extends ParseSchemaOptions & {
     rootSchema: IdSchema;
 }, A extends string, P extends string | undefined, R extends JSONSchema7, D extends string = ParseDomain<O["rootSchema"]["$id"]>, C extends string = Join<[D, A], "/">> = C extends keyof O["references"] ? ParseReference<O["references"][C], O, P, R> : M.Never;
 export {};

lib/types/parse-schema/references/utils.d.ts

 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../../definitions";
-import type { DeepGet, Split, Tail } from "../../type-utils";
+import type { JSONSchema7 } from "~/definitions";
+import type { DeepGet, Split, Tail } from "~/type-utils";
 import type { ParseSchema, ParseSchemaOptions } from "../index";
 import type { MergeSubSchema } from "../utils";
-export declare type ParseReference<Sc extends JSONSchema7, O extends ParseSchemaOptions, P extends string | undefined, R extends JSONSchema7, C extends JSONSchema7 = P extends string ? DeepGet<Sc, Tail<Split<P, "/">>, false> : Sc> = M.$Intersect<ParseSchema<C, O>, ParseSchema<MergeSubSchema<C, R>, O>>;
+export type ParseReference<Sc extends JSONSchema7, O extends ParseSchemaOptions, P extends string | undefined, R extends JSONSchema7, C extends JSONSchema7 = P extends string ? DeepGet<Sc, Tail<Split<P, "/">>, false> : Sc> = M.$Intersect<ParseSchema<C, O>, ParseSchema<MergeSubSchema<C, R>, O>>;

lib/types/parse-schema/singleType.d.ts

 import type { JSONSchema7TypeName } from "json-schema";
 import type { M } from "ts-algebra";
-import type { JSONSchema7 } from "../definitions";
+import type { JSONSchema7 } from "~/definitions";
 import type { ParseArraySchema, ArraySchema } from "./array";
 import type { ParseSchemaOptions } from "./index";
 import type { ParseObjectSchema, ObjectSchema } from "./object";
-export declare type SingleTypeSchema = JSONSchema7 & {
+export type SingleTypeSchema = JSONSchema7 & {
     type: JSONSchema7TypeName;
 };
-export declare type ParseSingleTypeSchema<S extends SingleTypeSchema, O extends ParseSchemaOptions> = S extends {
+export type ParseSingleTypeSchema<S extends SingleTypeSchema, O extends ParseSchemaOptions> = S extends {
     type: "null";
@@ -12,0 +12,0 @@ } ? M.Primitive<null> : S extends {

lib/types/parse-schema/utils.d.ts

@@ -1,3 +0,3 @@
-import type { JSONSchema7 } from "../definitions";
-declare type RemoveInvalidAdditionalItems<S extends JSONSchema7> = S extends {
+import type { JSONSchema7 } from "~/definitions";
+type RemoveInvalidAdditionalItems<S extends JSONSchema7> = S extends {
     items: JSONSchema7 | JSONSchema7[];
@@ -9,3 +9,3 @@ } ? S extends {
 } : S extends boolean ? S : Omit<S, "additionalItems">;
-declare type EmptySchema = {
+type EmptySchema = {
     properties: {};
@@ -15,3 +15,3 @@ additionalProperties: true;
 };
-export declare type MergeSubSchema<P extends JSONSchema7, S extends JSONSchema7, R extends JSONSchema7 = RemoveInvalidAdditionalItems<S>, C extends JSONSchema7 = Omit<EmptySchema, keyof R> & R> = Omit<P, keyof C> & C;
+export type MergeSubSchema<P extends JSONSchema7, S extends JSONSchema7, R extends JSONSchema7 = RemoveInvalidAdditionalItems<S>, C extends JSONSchema7 = Omit<EmptySchema, keyof R> & R> = Omit<P, keyof C> & C;
 export {};

lib/types/type-utils/and.d.ts

@@ -1,1 +0,1 @@
-export declare type And<A, B> = A extends true ? B extends true ? true : false : false;
+export type And<A, B> = A extends true ? B extends true ? true : false : false;

lib/types/type-utils/compute.d.ts

 import type { DoesExtend } from "./extends";
 import type { If } from "./if";
 import type { Key } from "./key";
-export declare type Compute<A, Seen = never> = A extends Function | Error | Date | {
+export type Compute<A, Seen = never> = A extends Function | Error | Date | {
     readonly [Symbol.toStringTag]: string;
@@ -6,0 +6,0 @@ } | RegExp | Generator ? A : If<DoesExtend<Seen, A>, A, A extends Array<unknown> ? A extends Array<Record<Key, unknown>> ? Array<{

lib/types/type-utils/extends.d.ts

@@ -1,1 +0,1 @@
-export declare type DoesExtend<A, B> = [A] extends [B] ? true : false;
+export type DoesExtend<A, B> = [A] extends [B] ? true : false;

lib/types/type-utils/get.d.ts

@@ -1,4 +0,4 @@
-export declare type DeepGet<O, P extends string[], D = undefined> = P extends [
+export type DeepGet<O, P extends string[], D = undefined> = P extends [
     infer H,
     ...infer T
 ] ? H extends string ? T extends string[] ? H extends keyof O ? DeepGet<O[H], T, D> : D : never : never : O;

lib/types/type-utils/if.d.ts

@@ -1,1 +0,1 @@
-export declare type If<B extends boolean, T, E = never> = B extends true ? T : E;
+export type If<B extends boolean, T, E = never> = B extends true ? T : E;

lib/types/type-utils/join.d.ts

@@ -1,1 +0,1 @@
-export declare type Join<S extends string[], D extends string = ","> = S extends [] ? "" : S extends [string] ? `${S[0]}` : S extends [string, ...infer T] ? T extends string[] ? `${S[0]}${D}${Join<T, D>}` : never : string;
+export type Join<S extends string[], D extends string = ","> = S extends [] ? "" : S extends [string] ? `${S[0]}` : S extends [string, ...infer T] ? T extends string[] ? `${S[0]}${D}${Join<T, D>}` : never : string;

lib/types/type-utils/key.d.ts

@@ -1,1 +0,1 @@
-export declare type Key = string | number | symbol;
+export type Key = string | number | symbol;

lib/types/type-utils/narrow.d.ts

@@ -1,3 +0,3 @@
-export declare type Narrow<A> = A extends Promise<infer T> ? Promise<Narrow<T>> : A extends (...args: infer P) => infer R ? (...args: Narrow<P>) => Narrow<R> : A extends [] ? [] : A extends object ? {
+export type Narrow<A> = A extends Promise<infer T> ? Promise<Narrow<T>> : A extends (...args: infer P) => infer R ? (...args: Narrow<P>) => Narrow<R> : A extends [] ? [] : A extends object ? {
     [key in keyof A]: Narrow<A[key]>;
 } : A extends string | number | boolean | bigint ? A : never;

lib/types/type-utils/pop.d.ts

@@ -1,1 +0,1 @@
-export declare type Pop<L extends unknown[]> = L extends readonly [...infer LBody, unknown] | readonly [...infer LBody, unknown?] ? LBody : L;
+export type Pop<L extends unknown[]> = L extends readonly [...infer LBody, unknown] | readonly [...infer LBody, unknown?] ? LBody : L;

lib/types/type-utils/readonly.d.ts

@@ -1,3 +0,3 @@
-export declare type DeepReadonly<T> = T extends Record<string | number | symbol, any> ? {
+export type DeepReadonly<T> = T extends Record<string | number | symbol, any> ? {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
 } : T;

lib/types/type-utils/reverse.d.ts

@@ -1,1 +0,1 @@
-export declare type Reverse<L extends unknown[]> = L extends [infer H, ...infer T] ? [...Reverse<T>, H] : L;
+export type Reverse<L extends unknown[]> = L extends [infer H, ...infer T] ? [...Reverse<T>, H] : L;

lib/types/type-utils/split.d.ts

 import { Pop } from "./pop";
-declare type RecSplit<S extends string, D extends string = ""> = S extends `${infer BS}${D}${infer AS}` ? [BS, ...RecSplit<AS, D>] : [S];
-export declare type Split<S extends string, D extends string = "", R extends string[] = RecSplit<S, D>> = D extends "" ? Pop<R> : R;
+type RecSplit<S extends string, D extends string = ""> = S extends `${infer BS}${D}${infer AS}` ? [BS, ...RecSplit<AS, D>] : [S];
+export type Split<S extends string, D extends string = "", R extends string[] = RecSplit<S, D>> = D extends "" ? Pop<R> : R;
 export {};

lib/types/type-utils/tail.d.ts

@@ -1,1 +0,1 @@
-export declare type Tail<L extends unknown[]> = L extends readonly [] ? L : L extends readonly [unknown?, ...infer T] ? T : L;
+export type Tail<L extends unknown[]> = L extends readonly [] ? L : L extends readonly [unknown?, ...infer T] ? T : L;

lib/types/type-utils/writable.d.ts

@@ -1,3 +0,3 @@
-export declare type DeepWritable<T> = {
+export type DeepWritable<T> = {
     -readonly [P in keyof T]: DeepWritable<T[P]>;
 };

lib/types/utils/asConst.d.ts

@@ -1,2 +0,2 @@
-import type { Narrow } from "../type-utils";
+import type { Narrow } from "~/type-utils";
 export declare const asConst: <A>(narrowed: Narrow<A>) => Narrow<A>;

lib/types/utils/type-guards/compiler.d.ts

@@ -1,6 +0,6 @@
-import type { FromSchema, JSONSchema, FromSchemaOptions, FromSchemaDefaultOptions } from "../../index";
-export declare type $Compiler<C extends unknown[] = [], V extends unknown[] = []> = (schema: JSONSchema, ...compilingOptions: C) => (data: unknown, ...validationOptions: V) => boolean;
-export declare type Compiler<O extends FromSchemaOptions = FromSchemaDefaultOptions, C extends unknown[] = [], V extends unknown[] = []> = <S extends JSONSchema, T = FromSchema<S, O>>(schema: S, ...compilingOptions: C) => (data: unknown, ...validationOptions: V) => data is T;
-declare type CompilerWrapper = <O extends FromSchemaOptions = FromSchemaDefaultOptions, C extends unknown[] = [], V extends unknown[] = []>(compiler: $Compiler<C, V>) => Compiler<O, C, V>;
+import type { FromSchema, JSONSchema, FromSchemaOptions, FromSchemaDefaultOptions } from "~/index";
+export type $Compiler<C extends unknown[] = [], V extends unknown[] = []> = (schema: JSONSchema, ...compilingOptions: C) => (data: unknown, ...validationOptions: V) => boolean;
+export type Compiler<O extends FromSchemaOptions = FromSchemaDefaultOptions, C extends unknown[] = [], V extends unknown[] = []> = <S extends JSONSchema, T = FromSchema<S, O>>(schema: S, ...compilingOptions: C) => (data: unknown, ...validationOptions: V) => data is T;
+type CompilerWrapper = <O extends FromSchemaOptions = FromSchemaDefaultOptions, C extends unknown[] = [], V extends unknown[] = []>(compiler: $Compiler<C, V>) => Compiler<O, C, V>;
 export declare const wrapCompilerAsTypeGuard: CompilerWrapper;
 export {};

lib/types/utils/type-guards/validator.d.ts

@@ -1,6 +0,6 @@
-import type { FromSchema, JSONSchema, FromSchemaOptions, FromSchemaDefaultOptions } from "../../index";
-export declare type $Validator<V extends unknown[] = []> = (schema: JSONSchema, data: unknown, ...validationOptions: V) => boolean;
-export declare type Validator<O extends FromSchemaOptions = FromSchemaDefaultOptions, V extends unknown[] = []> = <S extends JSONSchema, T = FromSchema<S, O>>(schema: S, data: unknown, ...validationOptions: V) => data is T;
-declare type ValidatorWrapper = <O extends FromSchemaOptions = FromSchemaDefaultOptions, V extends unknown[] = []>(validator: $Validator<V>) => Validator<O, V>;
+import type { FromSchema, JSONSchema, FromSchemaOptions, FromSchemaDefaultOptions } from "~/index";
+export type $Validator<V extends unknown[] = []> = (schema: JSONSchema, data: unknown, ...validationOptions: V) => boolean;
+export type Validator<O extends FromSchemaOptions = FromSchemaDefaultOptions, V extends unknown[] = []> = <S extends JSONSchema, T = FromSchema<S, O>>(schema: S, data: unknown, ...validationOptions: V) => data is T;
+type ValidatorWrapper = <O extends FromSchemaOptions = FromSchemaDefaultOptions, V extends unknown[] = []>(validator: $Validator<V>) => Validator<O, V>;
 export declare const wrapValidatorAsTypeGuard: ValidatorWrapper;
 export {};

package.json

 {
   "name": "json-schema-to-ts",
-  "version": "2.8.2",
+  "version": "2.9.0",
   "description": "Infer typescript types from your JSON schemas!",
@@ -20,3 +20,4 @@ "main": "lib/cjs/index.js",
     "build-esm": "NODE_ENV=esm yarn transpile --out-dir lib/esm --source-maps",
-    "build-types": "ttsc -p tsconfig.build.json"
+    "build-types": "ttsc -p tsconfig.build.json",
+    "set-package-version": "ts-node scripts/setPackageVersion"
   },
@@ -58,2 +59,3 @@ "dependencies": {
     "ts-jest": "^28.0.2",
+    "ts-node": "^10.9.1",
     "ts-toolbelt": "^9.6.0",
@@ -84,2 +86,2 @@ "ts-unused-exports": "^8.0.0",
   "homepage": "https://github.com/ThomasAribart/json-schema-to-ts#readme"
-}
+}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

116935

decreased by-0.66%

Dev dependency count

34

increased by3.03%

No dependency changes