@nmtjs/type 0.12.4 → 0.12.6

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import * as type from './types/type.ts';
+export * from './types/base.ts';
+export { type, type as t };
+export default type;

package/dist/index.js

@@ -1,8 +1,6 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import * as type from "./types/type.js";
 zod.config(zod.core.locales.en());
 export * from "./types/base.js";
 export { type, type as t };
 export default type;
-
-//# sourceMappingURL=index.js.map

package/dist/temporal.d.ts

@@ -0,0 +1 @@
+export * from './types/temporal.ts';

package/dist/temporal.js

@@ -1,3 +1 @@
 export * from "./types/temporal.js";
-
-//# sourceMappingURL=temporal.js.map

package/dist/types/any.d.ts

@@ -0,0 +1,6 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType } from './base.ts';
+export declare class AnyType extends BaseType<zod.ZodMiniAny> {
+    static factory(): AnyType;
+}
+export declare const any: typeof AnyType.factory;

package/dist/types/any.js

@@ -1,10 +1,10 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 export class AnyType extends BaseType {
-	static factory() {
-		return new AnyType({ encodedZodType: zod.any() });
-	}
+    static factory() {
+        return new AnyType({
+            encodedZodType: zod.any(),
+        });
+    }
 }
 export const any = AnyType.factory;
-
-//# sourceMappingURL=any.js.map

package/dist/types/array.d.ts

@@ -0,0 +1,13 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType } from './base.ts';
+type Check = zod.core.CheckFn<any[]> | zod.core.$ZodCheck<any[]>;
+export declare class ArrayType<T extends BaseType = BaseType> extends BaseType<zod.ZodMiniArray<T['encodedZodType']>, zod.ZodMiniArray<T['decodedZodType']>, {
+    element: T;
+}> {
+    static factory<T extends BaseType>(element: T, ...checks: Check[]): ArrayType<T>;
+    min(value: number): ArrayType<T>;
+    max(value: number): ArrayType<T>;
+    length(value: number): ArrayType<T>;
+}
+export declare const array: typeof ArrayType.factory;
+export {};

package/dist/types/array.js

@@ -1,27 +1,25 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 export class ArrayType extends BaseType {
-	static factory(element, ...checks) {
-		return new ArrayType({
-			encodedZodType: zod.array(element.encodedZodType).check(...checks),
-			decodedZodType: zod.array(element.decodedZodType).check(...checks),
-			params: { checks },
-			props: { element }
-		});
-	}
-	min(value) {
-		const check = zod.minLength(value);
-		return ArrayType.factory(this.props.element, ...this.params.checks, check);
-	}
-	max(value) {
-		const check = zod.maxLength(value);
-		return ArrayType.factory(this.props.element, ...this.params.checks, check);
-	}
-	length(value) {
-		const check = zod.length(value);
-		return ArrayType.factory(this.props.element, ...this.params.checks, check);
-	}
+    static factory(element, ...checks) {
+        return new ArrayType({
+            encodedZodType: zod.array(element.encodedZodType).check(...checks),
+            decodedZodType: zod.array(element.decodedZodType).check(...checks),
+            params: { checks },
+            props: { element },
+        });
+    }
+    min(value) {
+        const check = zod.minLength(value);
+        return ArrayType.factory(this.props.element, ...this.params.checks, check);
+    }
+    max(value) {
+        const check = zod.maxLength(value);
+        return ArrayType.factory(this.props.element, ...this.params.checks, check);
+    }
+    length(value) {
+        const check = zod.length(value);
+        return ArrayType.factory(this.props.element, ...this.params.checks, check);
+    }
 }
 export const array = ArrayType.factory;
-
-//# sourceMappingURL=array.js.map

package/dist/types/base.d.ts

@@ -0,0 +1,62 @@
+import * as zod from 'zod/v4-mini';
+export type PrimitiveValueType = string | number | boolean | null;
+export type PrimitiveZodType = zod.ZodMiniNever | zod.ZodMiniDefault | zod.ZodMiniNullable | zod.ZodMiniOptional | zod.ZodMiniString | zod.ZodMiniObject | zod.ZodMiniAny | zod.ZodMiniArray | zod.ZodMiniBoolean | zod.ZodMiniNumber | zod.ZodMiniEnum<any> | zod.ZodMiniLiteral<PrimitiveValueType> | zod.ZodMiniUnion | zod.ZodMiniIntersection | zod.ZodMiniRecord;
+export type SimpleZodType = zod.ZodMiniType;
+export type ZodType = SimpleZodType | zod.ZodMiniType;
+export type TypeProps = Record<string, any>;
+export type TypeMetadata<T = any> = {
+    id?: string;
+    description?: string;
+    examples?: T[];
+    title?: string;
+};
+export type TypeParams = {
+    encode?: (value: any) => any;
+    metadata?: TypeMetadata;
+    checks: Array<zod.core.CheckFn<any> | zod.core.$ZodCheck<any>>;
+};
+export type DefaultTypeParams = {
+    encode?: TypeParams['encode'];
+    metadata?: TypeMetadata;
+};
+export type BaseTypeAny<EncodedZodType extends SimpleZodType = SimpleZodType, DecodedZodType extends ZodType = zod.ZodMiniType> = BaseType<EncodedZodType, DecodedZodType, TypeProps>;
+export declare const typesRegistry: zod.z.core.$ZodRegistry<TypeMetadata<any>, zod.z.core.$ZodType<unknown, unknown, zod.z.core.$ZodTypeInternals<unknown, unknown>>>;
+export declare const NeemataTypeError: zod.z.core.$constructor<zod.z.core.$ZodError<unknown>, zod.z.core.$ZodIssue[]>;
+export type NeemataTypeError = zod.core.$ZodError;
+export declare abstract class BaseType<EncodedZodType extends SimpleZodType = SimpleZodType, DecodedZodType extends ZodType = EncodedZodType, Props extends TypeProps = TypeProps> {
+    readonly encodedZodType: EncodedZodType;
+    readonly decodedZodType: DecodedZodType;
+    readonly props: Props;
+    readonly params: TypeParams;
+    constructor({ encodedZodType, decodedZodType, props, params, }: {
+        encodedZodType: EncodedZodType;
+        decodedZodType?: DecodedZodType;
+        props?: Props;
+        params?: Partial<TypeParams>;
+    });
+    optional(): OptionalType<this>;
+    nullable(): NullableType<this>;
+    nullish(): OptionalType<NullableType<this>>;
+    default(value: this['encodedZodType']['_zod']['input']): DefaultType<this>;
+    title(title: string): this;
+    description(description: string): this;
+    examples(...examples: this['encodedZodType']['_zod']['input'][]): this;
+    meta(newMetadata: TypeMetadata): this;
+    encode(data: this['encodedZodType']['_zod']['input']): this['encodedZodType']['_zod']['output'];
+    decode(data: this['decodedZodType']['_zod']['input']): this['decodedZodType']['_zod']['output'];
+}
+export declare class OptionalType<Type extends BaseTypeAny = BaseTypeAny> extends BaseType<zod.ZodMiniOptional<Type['encodedZodType']>, zod.ZodMiniOptional<Type['decodedZodType']>, {
+    inner: Type;
+}> {
+    static factory<T extends BaseTypeAny>(type: T): OptionalType<T>;
+}
+export declare class NullableType<Type extends BaseTypeAny<any> = BaseTypeAny<any>> extends BaseType<zod.ZodMiniNullable<Type['encodedZodType']>, zod.ZodMiniNullable<Type['decodedZodType']>, {
+    inner: Type;
+}> {
+    static factory<T extends BaseTypeAny<any>>(type: T): NullableType<T>;
+}
+export declare class DefaultType<Type extends BaseTypeAny = BaseTypeAny> extends BaseType<zod.ZodMiniDefault<Type['encodedZodType']>, zod.ZodMiniDefault<Type['decodedZodType']>, {
+    inner: Type;
+}> {
+    static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any): DefaultType<T>;
+}

package/dist/types/base.js

@@ -1,75 +1,77 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 export const typesRegistry = zod.registry();
 export const NeemataTypeError = zod.core.$ZodError;
 export class BaseType {
-	encodedZodType;
-	decodedZodType;
-	props;
-	params;
-	constructor({ encodedZodType, decodedZodType = encodedZodType, props = {}, params = {} }) {
-		this.encodedZodType = encodedZodType;
-		this.decodedZodType = decodedZodType;
-		this.props = props;
-		this.params = Object.assign({ checks: [] }, params);
-	}
-	optional() {
-		return OptionalType.factory(this);
-	}
-	nullable() {
-		return NullableType.factory(this);
-	}
-	nullish() {
-		return this.nullable().optional();
-	}
-	default(value) {
-		return DefaultType.factory(this, value);
-	}
-	title(title) {
-		return this.meta({ title });
-	}
-	description(description) {
-		return this.meta({ description });
-	}
-	examples(...examples) {
-		return this.meta({ examples: this.params.encode ? examples.map(this.params.encode) : examples });
-	}
-	meta(newMetadata) {
-		const metadata = typesRegistry.get(this.encodedZodType) ?? {};
-		Object.assign(metadata, newMetadata);
-		typesRegistry.add(this.encodedZodType, metadata);
-		return this;
-	}
-	encode(data) {
-		return this.encodedZodType.parse(data, { reportInput: true });
-	}
-	decode(data) {
-		return this.decodedZodType.parse(data, { reportInput: true });
-	}
+    encodedZodType;
+    decodedZodType;
+    props;
+    params;
+    constructor({ encodedZodType, decodedZodType = encodedZodType, props = {}, params = {}, }) {
+        this.encodedZodType = encodedZodType;
+        this.decodedZodType = decodedZodType;
+        this.props = props;
+        this.params = Object.assign({ checks: [] }, params);
+    }
+    optional() {
+        return OptionalType.factory(this);
+    }
+    nullable() {
+        return NullableType.factory(this);
+    }
+    nullish() {
+        return this.nullable().optional();
+    }
+    default(value) {
+        return DefaultType.factory(this, value);
+    }
+    title(title) {
+        return this.meta({ title });
+    }
+    description(description) {
+        return this.meta({ description });
+    }
+    examples(...examples) {
+        return this.meta({
+            examples: this.params.encode
+                ? examples.map(this.params.encode)
+                : examples,
+        });
+    }
+    meta(newMetadata) {
+        const metadata = typesRegistry.get(this.encodedZodType) ?? {};
+        Object.assign(metadata, newMetadata);
+        typesRegistry.add(this.encodedZodType, metadata);
+        return this;
+    }
+    encode(data) {
+        return this.encodedZodType.parse(data, { reportInput: true });
+    }
+    decode(data) {
+        return this.decodedZodType.parse(data, { reportInput: true });
+    }
 }
 export class OptionalType extends BaseType {
-	static factory(type) {
-		return new OptionalType({
-			encodedZodType: zod.optional(type.encodedZodType),
-			props: { inner: type }
-		});
-	}
+    static factory(type) {
+        return new OptionalType({
+            encodedZodType: zod.optional(type.encodedZodType),
+            props: { inner: type },
+        });
+    }
 }
 export class NullableType extends BaseType {
-	static factory(type) {
-		return new NullableType({
-			encodedZodType: zod.nullable(type.encodedZodType),
-			props: { inner: type }
-		});
-	}
+    static factory(type) {
+        return new NullableType({
+            encodedZodType: zod.nullable(type.encodedZodType),
+            props: { inner: type },
+        });
+    }
 }
 export class DefaultType extends BaseType {
-	static factory(type, defaultValue) {
-		return new DefaultType({
-			encodedZodType: zod._default(type.encodedZodType, type.params.encode?.(defaultValue) ?? defaultValue),
-			decodedZodType: zod._default(type.decodedZodType, defaultValue),
-			props: { inner: type }
-		});
-	}
+    static factory(type, defaultValue) {
+        return new DefaultType({
+            encodedZodType: zod._default(type.encodedZodType, type.params.encode?.(defaultValue) ?? defaultValue),
+            decodedZodType: zod._default(type.decodedZodType, defaultValue),
+            props: { inner: type },
+        });
+    }
 }
-
-//# sourceMappingURL=base.js.map

package/dist/types/boolean.d.ts

@@ -0,0 +1,6 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType } from './base.ts';
+export declare class BooleanType extends BaseType<zod.ZodMiniBoolean<boolean>> {
+    static factory(): BooleanType;
+}
+export declare const boolean: typeof BooleanType.factory;

package/dist/types/boolean.js

@@ -1,10 +1,10 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 export class BooleanType extends BaseType {
-	static factory() {
-		return new BooleanType({ encodedZodType: zod.boolean() });
-	}
+    static factory() {
+        return new BooleanType({
+            encodedZodType: zod.boolean(),
+        });
+    }
 }
 export const boolean = BooleanType.factory;
-
-//# sourceMappingURL=boolean.js.map

package/dist/types/custom.d.ts

@@ -0,0 +1,14 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType, type SimpleZodType, type ZodType } from './base.ts';
+export type CustomTransformFn<I, O> = (value: I) => O;
+export declare abstract class TransformType<Type, EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>, DecodedType extends ZodType = zod.ZodMiniType<Type, Type>> extends BaseType<zod.ZodMiniPipe<zod.ZodMiniType<DecodedType['_zod']['output'], DecodedType['_zod']['input']>, EncodedType>, zod.ZodMiniPipe<EncodedType, zod.ZodMiniType<DecodedType['_zod']['output'], DecodedType['_zod']['input']>>> {
+}
+export declare class CustomType<Type, EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>, DecodedType extends ZodType = zod.ZodMiniType<Type, Type>> extends TransformType<Type, EncodedType, DecodedType> {
+    static factory<Type, EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>, DecodedType extends ZodType = zod.ZodMiniType<Type, Type>>({ decode, encode, error, type, }: {
+        decode: CustomTransformFn<EncodedType['_zod']['input'], DecodedType['_zod']['output']>;
+        encode: CustomTransformFn<DecodedType['_zod']['input'], EncodedType['_zod']['output']>;
+        error?: string | zod.core.$ZodErrorMap<zod.core.$ZodIssueBase>;
+        type?: EncodedType;
+    }): CustomType<Type, EncodedType, DecodedType>;
+}
+export declare const custom: typeof CustomType.factory;

package/dist/types/custom.js

@@ -1,25 +1,25 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
-export class TransformType extends BaseType {}
+export class TransformType extends BaseType {
+}
 export class CustomType extends TransformType {
-	static factory({ decode, encode, error, type = zod.any() }) {
-		return new CustomType({
-			encodedZodType: zod.pipe(zod.custom().check(zod.refine((val) => typeof val !== "undefined", {
-				error,
-				abort: true
-			}), zod.overwrite(encode)), type),
-			decodedZodType: zod.pipe(
-				type,
-				// @ts-expect-error
-				zod.custom().check(zod.refine((val) => typeof val !== "undefined", {
-					error,
-					abort: true
-				}), zod.overwrite(decode))
-),
-			params: { encode }
-		});
-	}
+    static factory({ decode, encode, error, type = zod.any(), }) {
+        return new CustomType({
+            encodedZodType: zod.pipe(zod.custom().check(zod.refine((val) => typeof val !== 'undefined', {
+                error,
+                abort: true,
+            }), zod.overwrite(encode)), type),
+            // @ts-expect-error
+            decodedZodType: zod.pipe(type, 
+            // @ts-expect-error
+            zod
+                .custom()
+                .check(zod.refine((val) => typeof val !== 'undefined', {
+                error,
+                abort: true,
+            }), zod.overwrite(decode))),
+            params: { encode },
+        });
+    }
 }
 export const custom = CustomType.factory;
-
-//# sourceMappingURL=custom.js.map

package/dist/types/date.d.ts

@@ -0,0 +1,6 @@
+import * as zod from 'zod/v4-mini';
+import { CustomType, TransformType } from './custom.ts';
+export declare class DateType extends TransformType<Date, zod.ZodMiniUnion<[zod.iso.ZodMiniISODate, zod.iso.ZodMiniISODateTime]>> {
+    static factory(): CustomType<Date, zod.ZodMiniUnion<[zod.z.iso.ZodMiniISODate, zod.z.iso.ZodMiniISODateTime]>, zod.ZodMiniType<Date, Date, zod.z.core.$ZodTypeInternals<Date, Date>>>;
+}
+export declare const date: typeof DateType.factory;

package/dist/types/date.js

@@ -1,14 +1,12 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { CustomType, TransformType } from "./custom.js";
 export class DateType extends TransformType {
-	static factory() {
-		return CustomType.factory({
-			decode: (value) => new Date(value),
-			encode: (value) => value.toISOString(),
-			type: zod.union([zod.iso.date(), zod.iso.datetime()])
-		});
-	}
+    static factory() {
+        return CustomType.factory({
+            decode: (value) => new Date(value),
+            encode: (value) => value.toISOString(),
+            type: zod.union([zod.iso.date(), zod.iso.datetime()]),
+        });
+    }
 }
 export const date = DateType.factory;
-
-//# sourceMappingURL=date.js.map

package/dist/types/enum.d.ts

@@ -0,0 +1,10 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType } from './base.ts';
+export declare class EnumType<T extends zod.core.util.EnumLike = zod.core.util.EnumLike> extends BaseType<zod.ZodMiniEnum<T>, zod.ZodMiniEnum<T>, {
+    values: T;
+}> {
+    static factory<T extends zod.core.util.EnumLike>(values: T): EnumType<T>;
+    static factory<T extends string[]>(values: T): EnumType<zod.core.util.ToEnum<T[number]>>;
+}
+declare const _enum: typeof EnumType.factory;
+export { _enum as enum };

package/dist/types/enum.js

@@ -1,14 +1,12 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 export class EnumType extends BaseType {
-	static factory(values) {
-		return new EnumType({
-			encodedZodType: zod.enum(values),
-			props: { values }
-		});
-	}
+    static factory(values) {
+        return new EnumType({
+            encodedZodType: zod.enum(values),
+            props: { values },
+        });
+    }
 }
 const _enum = EnumType.factory;
 export { _enum as enum };
-
-//# sourceMappingURL=enum.js.map

package/dist/types/literal.d.ts

@@ -0,0 +1,8 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType, type PrimitiveValueType } from './base.ts';
+export declare class LiteralType<T extends PrimitiveValueType = PrimitiveValueType> extends BaseType<zod.ZodMiniLiteral<T>, zod.ZodMiniLiteral<T>, {
+    value: T;
+}> {
+    static factory<T extends PrimitiveValueType>(value: T): LiteralType<T>;
+}
+export declare const literal: typeof LiteralType.factory;

package/dist/types/literal.js

@@ -1,13 +1,11 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 export class LiteralType extends BaseType {
-	static factory(value) {
-		return new LiteralType({
-			encodedZodType: zod.literal(value),
-			props: { value }
-		});
-	}
+    static factory(value) {
+        return new LiteralType({
+            encodedZodType: zod.literal(value),
+            props: { value },
+        });
+    }
 }
 export const literal = LiteralType.factory;
-
-//# sourceMappingURL=literal.js.map

package/dist/types/never.d.ts

@@ -0,0 +1,6 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType } from './base.ts';
+export declare class NeverType extends BaseType<zod.ZodMiniNever> {
+    static factory(): NeverType;
+}
+export declare const never: typeof NeverType.factory;

package/dist/types/never.js

@@ -1,10 +1,10 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 export class NeverType extends BaseType {
-	static factory() {
-		return new NeverType({ encodedZodType: zod.never() });
-	}
+    static factory() {
+        return new NeverType({
+            encodedZodType: zod.never(),
+        });
+    }
 }
 export const never = NeverType.factory;
-
-//# sourceMappingURL=never.js.map

package/dist/types/number.d.ts

@@ -0,0 +1,23 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType } from './base.ts';
+import { CustomType, TransformType } from './custom.ts';
+type Check = zod.core.CheckFn<number> | zod.core.$ZodCheck<number>;
+export declare class NumberType extends BaseType<zod.ZodMiniNumber<number>, zod.ZodMiniNumber<number>> {
+    static factory(...checks: Check[]): NumberType;
+    positive(): NumberType;
+    negative(): NumberType;
+    lt(value: number): NumberType;
+    lte(value: number): NumberType;
+    gte(value: number): NumberType;
+    gt(value: number): NumberType;
+}
+export declare class IntegerType extends NumberType {
+    static factory(...checks: Check[]): NumberType;
+}
+export declare class BigIntType extends TransformType<bigint, zod.ZodMiniString<string>> {
+    static factory(): CustomType<bigint, zod.ZodMiniString<string>, zod.ZodMiniType<bigint, bigint, zod.z.core.$ZodTypeInternals<bigint, bigint>>>;
+}
+export declare const number: typeof NumberType.factory;
+export declare const integer: typeof IntegerType.factory;
+export declare const bigInt: typeof BigIntType.factory;
+export {};

package/dist/types/number.js

@@ -1,49 +1,47 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 import { CustomType, TransformType } from "./custom.js";
 export class NumberType extends BaseType {
-	static factory(...checks) {
-		return new NumberType({
-			encodedZodType: zod.number().check(...checks),
-			params: { checks }
-		});
-	}
-	positive() {
-		return NumberType.factory(...this.params.checks, zod.gte(0));
-	}
-	negative() {
-		return NumberType.factory(...this.params.checks, zod.lte(0));
-	}
-	lt(value) {
-		return NumberType.factory(...this.params.checks, zod.lt(value));
-	}
-	lte(value) {
-		return NumberType.factory(...this.params.checks, zod.lte(value));
-	}
-	gte(value) {
-		return NumberType.factory(...this.params.checks, zod.gte(value));
-	}
-	gt(value) {
-		return NumberType.factory(...this.params.checks, zod.gt(value));
-	}
+    static factory(...checks) {
+        return new NumberType({
+            encodedZodType: zod.number().check(...checks),
+            params: { checks },
+        });
+    }
+    positive() {
+        return NumberType.factory(...this.params.checks, zod.gte(0));
+    }
+    negative() {
+        return NumberType.factory(...this.params.checks, zod.lte(0));
+    }
+    lt(value) {
+        return NumberType.factory(...this.params.checks, zod.lt(value));
+    }
+    lte(value) {
+        return NumberType.factory(...this.params.checks, zod.lte(value));
+    }
+    gte(value) {
+        return NumberType.factory(...this.params.checks, zod.gte(value));
+    }
+    gt(value) {
+        return NumberType.factory(...this.params.checks, zod.gt(value));
+    }
 }
 export class IntegerType extends NumberType {
-	static factory(...checks) {
-		return NumberType.factory(...checks, zod.int());
-	}
+    static factory(...checks) {
+        return NumberType.factory(...checks, zod.int());
+    }
 }
 export class BigIntType extends TransformType {
-	static factory() {
-		return CustomType.factory({
-			decode: (value) => BigInt(value),
-			encode: (value) => value.toString(),
-			type: zod.string().check(zod.regex(/^-?\d+$/)),
-			error: "Invalid bigint format"
-		});
-	}
+    static factory() {
+        return CustomType.factory({
+            decode: (value) => BigInt(value),
+            encode: (value) => value.toString(),
+            type: zod.string().check(zod.regex(/^-?\d+$/)),
+            error: 'Invalid bigint format',
+        });
+    }
 }
 export const number = NumberType.factory;
 export const integer = IntegerType.factory;
 export const bigInt = BigIntType.factory;
-
-//# sourceMappingURL=number.js.map