@nmtjs/type 0.14.5 → 0.15.0-beta.2

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Denis Ilchyshyn
+Copyright (c) 2025 Denys Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -6,4 +6,4 @@
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers

package/dist/index.js

@@ -1,7 +1,11 @@
 import { en } from 'zod/locales';
 import { config } from 'zod/mini';
 import * as type from "./types/_type.js";
-config(en());
+export * from "./types/_convert.js";
+export * from "./types/_utils.js";
 export * from "./types/base.js";
 export { type, type as t };
 export default type;
+export function registerDefaultLocale() {
+    config(en());
+}

package/dist/types/_convert.js

@@ -0,0 +1,55 @@
+import { toJSONSchema } from 'zod/mini';
+import { AnyType } from "./any.js";
+import { ArrayType } from "./array.js";
+import { NullableType, OptionalType } from "./base.js";
+import { BooleanType } from "./boolean.js";
+import { CustomType } from "./custom.js";
+import { DateType } from "./date.js";
+import { LiteralType } from "./literal.js";
+import { NumberType } from "./number.js";
+import { ObjectType } from "./object.js";
+import { StringType } from "./string.js";
+import { TupleType } from "./tuple.js";
+export function typeToString(type) {
+    switch (true) {
+        case type instanceof OptionalType:
+            return `?<${typeToString(type.props.inner)}>`;
+        case type instanceof NullableType:
+            return `null | ${typeToString(type.props.inner)}`;
+        case type instanceof StringType:
+            return 'string';
+        case type instanceof NumberType:
+            return 'number';
+        case type instanceof LiteralType:
+            return `literal(${type.props.value})`;
+        case type instanceof BooleanType:
+            return 'boolean';
+        case type instanceof DateType:
+            return 'string';
+        case type instanceof ArrayType:
+            return `array<${typeToString(type.props.element)}>`;
+        case type instanceof ObjectType: {
+            const props = type.props.properties;
+            const propsStrings = Object.keys(props).map((key) => `${key}: ${typeToString(props[key])}`);
+            return `{ ${propsStrings.join(', ')} }`;
+        }
+        case type instanceof TupleType: {
+            const elements = type.props.elements;
+            const elementsStrings = elements.map((el) => typeToString(el));
+            const rest = type.props.rest
+                ? `, ...${typeToString(type.props.rest)}`
+                : '';
+            return `[${elementsStrings.join(', ')}${rest}]`;
+        }
+        case type instanceof AnyType:
+            return 'any';
+        case type instanceof CustomType:
+            return typeToJsonSchema(type, 'decode').type || 'custom';
+        default:
+            return 'unknown';
+    }
+}
+export function typeToJsonSchema(type, mode, options) {
+    const zodType = { encode: type.encodeZodType, decode: type.decodeZodType }[mode];
+    return toJSONSchema(zodType, options);
+}

package/dist/types/_type.js

@@ -6,6 +6,7 @@ export * from "./date.js";
 export * from "./enum.js";
 export * from "./literal.js";
 export * from "./never.js";
+export * from "./null.js";
 export * from "./number.js";
 export * from "./object.js";
 export * from "./string.js";

package/dist/types/custom.js

@@ -1,16 +1,32 @@
-import { any, overwrite, pipe, refine, custom as zodCustom } from 'zod/mini';
+import { any, overwrite, pipe, refine, superRefine, custom as zodCustom, } from 'zod/mini';
 import { BaseType } from "./base.js";
 export class TransformType extends BaseType {
 }
 export class CustomType extends TransformType {
-    static factory({ decode, encode, error, type = any(), }) {
-        return new CustomType({
-            encodeZodType: pipe(zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(encode)), type),
+    static factory({ decode, encode, validation, error, type = any(), prototype, }) {
+        const _validation = validation
+            ? typeof validation === 'function'
+                ? { encode: validation, decode: validation }
+                : validation
+            : undefined;
+        const instance = new CustomType({
+            encodeZodType: pipe(zodCustom().check(...[
+                refine((val) => typeof val !== 'undefined', { abort: true }),
+                _validation?.encode ? superRefine(_validation.encode) : undefined,
+                overwrite(encode),
+            ].filter((v) => !!v)), type),
             decodeZodType: pipe(type, 
             // @ts-expect-error
-            zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(decode))),
+            zodCustom().check(...[
+                refine((val) => typeof val !== 'undefined', { abort: true }),
+                overwrite(decode),
+                _validation?.decode ? superRefine(_validation.decode) : undefined,
+            ].filter((v) => !!v))),
             params: { encode },
         });
+        if (prototype)
+            Object.setPrototypeOf(instance, prototype);
+        return instance;
     }
 }
 export const custom = CustomType.factory;

package/dist/types/date.js

@@ -6,6 +6,7 @@ export class DateType extends TransformType {
             decode: (value) => new Date(value),
             encode: (value) => value.toISOString(),
             type: union([iso.date(), iso.datetime()]),
+            prototype: DateType.prototype,
         });
     }
 }

package/dist/types/null.js

@@ -0,0 +1,9 @@
+import { null as zodNull } from 'zod/mini';
+import { BaseType } from "./base.js";
+export class NullType extends BaseType {
+    static factory() {
+        return new NullType({ encodeZodType: zodNull() });
+    }
+}
+const _null = NullType.factory;
+export { _null as null };

package/dist/types/object.js

@@ -1,5 +1,5 @@
-import { object as zodObject, record as zodRecord } from 'zod/mini';
-import { zodPlainType } from "./_plain.js";
+import { looseObject as zodLooseObject, object as zodObject, record as zodRecord, } from 'zod/mini';
+import { zodPlainType } from "./_utils.js";
 import { BaseType } from "./base.js";
 import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
@@ -17,6 +17,21 @@ export class ObjectType extends BaseType {
         });
     }
 }
+export class LooseObjectType extends BaseType {
+    static factory(properties) {
+        const encodeProperties = {};
+        const decodeProperties = {};
+        for (const key in properties) {
+            encodeProperties[key] = properties[key].encodeZodType;
+            decodeProperties[key] = properties[key].decodeZodType;
+        }
+        return new LooseObjectType({
+            encodeZodType: zodLooseObject(encodeProperties),
+            decodeZodType: zodLooseObject(decodeProperties),
+            props: { properties },
+        });
+    }
+}
 export class RecordType extends BaseType {
     static factory(key, element) {
         return new RecordType({
@@ -57,4 +72,5 @@ export function partial(object) {
     return ObjectType.factory(properties);
 }
 export const object = ObjectType.factory;
+export const looseObject = LooseObjectType.factory;
 export const record = RecordType.factory;

package/package.json

@@ -7,48 +7,34 @@
     "README.md"
   ],
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "module-sync": "./dist/index.js"
-    },
-    "./*": {
-      "types": "./dist/types/*.d.ts",
-      "import": "./dist/types/*.js",
-      "module-sync": "./dist/types/*.js"
-    },
-    "./temporal": {
-      "types": "./dist/temporal/global.d.ts",
-      "import": "./dist/temporal/global.js",
-      "module-sync": "./dist/temporal/global.js"
-    },
-    "./temporal-polyfill": {
-      "types": "./dist/temporal/polyfill.d.ts",
-      "import": "./dist/temporal/polyfill.js",
-      "module-sync": "./dist/temporal/polyfill.js"
-    }
+    ".": "./dist/index.js",
+    "./*": "./dist/types/*.js",
+    "./temporal": "./dist/temporal/global.js",
+    "./temporal-polyfill": "./dist/temporal/polyfill.js"
   },
   "dependencies": {
     "temporal-spec": "^0.3.0"
   },
   "peerDependencies": {
     "temporal-polyfill": "^0.3.0",
-    "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.5"
+    "zod": "^4.1.0",
+    "@nmtjs/common": "0.15.0-beta.2"
   },
   "devDependencies": {
     "temporal-polyfill": "^0.3.0",
-    "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.5"
+    "zod": "^4.1.0",
+    "@nmtjs/common": "0.15.0-beta.2"
   },
   "peerDependenciesMeta": {
     "temporal-polyfill": {
       "optional": true
     }
   },
-  "version": "0.14.5",
+  "version": "0.15.0-beta.2",
   "scripts": {
+    "clean-build": "rm -rf ./dist",
     "build": "tsc",
+    "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/index.d.ts

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

package/dist/temporal/global.d.ts

@@ -1,8 +0,0 @@
-import 'temporal-spec/global';
-export declare const plainDate: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainDate, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainDate, import("temporal-spec").Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainDate, import("temporal-spec").Temporal.PlainDate>>>;
-export declare const plainDatetime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainDateTime, import("temporal-spec").Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainDateTime, import("temporal-spec").Temporal.PlainDateTime>>>;
-export declare const plainTime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainTime, import("temporal-spec").Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainTime, import("temporal-spec").Temporal.PlainTime>>>;
-export declare const zonedDatetime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.ZonedDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.ZonedDateTime, import("temporal-spec").Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.ZonedDateTime, import("temporal-spec").Temporal.ZonedDateTime>>>;
-export declare const duration: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.Duration, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.Duration, import("temporal-spec").Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.Duration, import("temporal-spec").Temporal.Duration>>>;
-export declare const plainYearMonth: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainYearMonth, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainYearMonth, import("temporal-spec").Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainYearMonth, import("temporal-spec").Temporal.PlainYearMonth>>>;
-export declare const plainMonthDay: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainMonthDay, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainMonthDay, import("temporal-spec").Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainMonthDay, import("temporal-spec").Temporal.PlainMonthDay>>>;

package/dist/temporal/polyfill.d.ts

@@ -1,8 +0,0 @@
-import { Temporal } from 'temporal-polyfill';
-export declare const plainDate: () => import("../types/custom.ts").CustomType<Temporal.PlainDate, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
-export declare const plainDatetime: () => import("../types/custom.ts").CustomType<Temporal.PlainDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
-export declare const plainTime: () => import("../types/custom.ts").CustomType<Temporal.PlainTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
-export declare const zonedDatetime: () => import("../types/custom.ts").CustomType<Temporal.ZonedDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
-export declare const duration: () => import("../types/custom.ts").CustomType<Temporal.Duration, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
-export declare const plainYearMonth: () => import("../types/custom.ts").CustomType<Temporal.PlainYearMonth, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
-export declare const plainMonthDay: () => import("../types/custom.ts").CustomType<Temporal.PlainMonthDay, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;

package/dist/types/_plain.d.ts

@@ -1,13 +0,0 @@
-import type { core, ZodMiniType } from 'zod/mini';
-export declare const PlainType: unique symbol;
-export type PlainType = typeof PlainType;
-export type ZodPlainType<T extends ZodMiniType<any, any, any>> = T & ZodMiniType<T['_zod']['output'] & {
-    [PlainType]?: true;
-}, T['_zod']['input'] & {
-    [PlainType]?: true;
-}, core.$ZodTypeInternals<T['_zod']['output'] & {
-    [PlainType]?: true;
-}, T['_zod']['input'] & {
-    [PlainType]?: true;
-}>>;
-export declare const zodPlainType: <T extends ZodMiniType<any, any, any>>(type: T) => ZodPlainType<T>;

package/dist/types/_type.d.ts

@@ -1,32 +0,0 @@
-import type { BaseTypeAny } from './base.ts';
-export * from './any.ts';
-export * from './array.ts';
-export * from './boolean.ts';
-export * from './custom.ts';
-export * from './date.ts';
-export * from './enum.ts';
-export * from './literal.ts';
-export * from './never.ts';
-export * from './number.ts';
-export * from './object.ts';
-export * from './string.ts';
-export * from './tuple.ts';
-export * from './union.ts';
-export declare namespace infer {
-    namespace decode {
-        type input<T extends BaseTypeAny> = T['decodeZodType']['_zod']['input'];
-        type output<T extends BaseTypeAny> = T['decodeZodType']['_zod']['output'];
-    }
-    namespace encode {
-        type input<T extends BaseTypeAny> = T['encodeZodType']['_zod']['input'];
-        type output<T extends BaseTypeAny> = T['encodeZodType']['_zod']['output'];
-    }
-    namespace decodeRaw {
-        type input<T extends BaseTypeAny> = T['decodeRawZodType']['_zod']['input'];
-        type output<T extends BaseTypeAny> = T['decodeRawZodType']['_zod']['output'];
-    }
-    namespace encodeRaw {
-        type input<T extends BaseTypeAny> = T['encodeRawZodType']['_zod']['input'];
-        type output<T extends BaseTypeAny> = T['encodeRawZodType']['_zod']['output'];
-    }
-}

package/dist/types/any.d.ts

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

package/dist/types/array.d.ts

@@ -1,14 +0,0 @@
-import type { core, ZodMiniArray } from 'zod/mini';
-import type { ZodPlainType } from './_plain.ts';
-import { BaseType } from './base.ts';
-type Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>;
-export declare class ArrayType<T extends BaseType = BaseType> extends BaseType<ZodMiniArray<T['encodeZodType']>, ZodMiniArray<T['decodeZodType']>, {
-    element: T;
-}, ZodPlainType<ZodMiniArray<T['encodeZodType']>>, ZodPlainType<ZodMiniArray<T['encodeZodType']>>> {
-    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/base.d.ts

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

package/dist/types/boolean.d.ts

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

package/dist/types/custom.d.ts

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

package/dist/types/date.d.ts

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

package/dist/types/enum.d.ts

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

package/dist/types/literal.d.ts

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

package/dist/types/never.d.ts

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

package/dist/types/number.d.ts

@@ -1,23 +0,0 @@
-import type { core, ZodMiniNumber, ZodMiniString } from 'zod/mini';
-import { BaseType } from './base.ts';
-import { CustomType, TransformType } from './custom.ts';
-type Check = core.CheckFn<number> | core.$ZodCheck<number>;
-export declare class NumberType extends BaseType<ZodMiniNumber<number>, 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, ZodMiniString<string>> {
-    static factory(): CustomType<bigint, ZodMiniString<string>, import("zod/mini").ZodMiniType<bigint, bigint, 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/object.d.ts

@@ -1,52 +0,0 @@
-import type { core, ZodMiniObject, ZodMiniRecord } from 'zod/mini';
-import type { ZodPlainType } from './_plain.ts';
-import type { BaseTypeAny, OptionalType } from './base.ts';
-import type { LiteralType } from './literal.ts';
-import type { StringType } from './string.ts';
-import { BaseType } from './base.ts';
-import { EnumType } from './enum.ts';
-export type ObjectTypeProps = {
-    [k: string]: BaseTypeAny;
-};
-export type AnyObjectType = ObjectType<ObjectTypeProps>;
-export declare class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<ZodMiniObject<{
-    [K in keyof T]: T[K]['encodeZodType'];
-}, core.$strict>, ZodMiniObject<{
-    [K in keyof T]: T[K]['decodeZodType'];
-}, core.$strict>, {
-    properties: T;
-}, ZodPlainType<ZodMiniObject<{
-    [K in keyof T]: T[K]['encodeZodType'];
-}, core.$strict>>, ZodPlainType<ZodMiniObject<{
-    [K in keyof T]: T[K]['decodeZodType'];
-}, core.$strict>>> {
-    static factory<T extends ObjectTypeProps = {}>(properties: T): ObjectType<T>;
-}
-export declare class RecordType<K extends LiteralType<string | number> | EnumType | StringType, E extends BaseType> extends BaseType<ZodMiniRecord<K['encodeZodType'], E['encodeZodType']>, ZodMiniRecord<K['decodeZodType'], E['decodeZodType']>, {
-    key: K;
-    element: E;
-}, ZodPlainType<ZodMiniRecord<K['encodeZodType'], E['encodeZodType']>>, ZodPlainType<ZodMiniRecord<K['decodeZodType'], E['decodeZodType']>>> {
-    static factory<K extends LiteralType<string | number> | EnumType | StringType, E extends BaseType>(key: K, element: E): RecordType<K, E>;
-}
-export declare function keyof<T extends AnyObjectType>(type: T): EnumType<core.util.ToEnum<Extract<keyof T['props']['properties'], string>>>;
-export declare function pick<T extends AnyObjectType, P extends {
-    [K in keyof T['props']['properties']]?: true;
-}>(source: T, pick: P): ObjectType<{
-    [K in keyof P]: P[K] extends true ? K extends keyof T['props']['properties'] ? T['props']['properties'][K] : never : never;
-}>;
-export declare function omit<T extends AnyObjectType, P extends {
-    [K in keyof T['props']['properties']]?: true;
-}>(source: T, omit: P): ObjectType<{
-    [K in keyof T['props']['properties'] as K extends keyof P ? never : K]: T['props']['properties'][K];
-}>;
-export declare function extend<T extends AnyObjectType, P extends ObjectTypeProps>(object1: T, properties: P): ObjectType<{
-    [K in keyof T['props']['properties'] | keyof P]: K extends keyof P ? P[K] : K extends keyof T['props']['properties'] ? T['props']['properties'][K] : never;
-}>;
-export declare function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(object1: T1, object2: T2): ObjectType<{
-    [K in keyof T1['props']['properties'] | keyof T2['props']['properties']]: K extends keyof T2['props']['properties'] ? T2['props']['properties'][K] : K extends keyof T1['props']['properties'] ? T1['props']['properties'][K] : never;
-}>;
-export declare function partial<T extends AnyObjectType, P extends T extends ObjectType<infer Props> ? Props : never>(object: T): ObjectType<{
-    [K in keyof P]: OptionalType<P[K]>;
-}>;
-export declare const object: typeof ObjectType.factory;
-export declare const record: typeof RecordType.factory;

package/dist/types/string.d.ts

@@ -1,22 +0,0 @@
-import type { core, ZodMiniString } from 'zod/mini';
-import { BaseType } from './base.ts';
-type Check = core.CheckFn<string> | core.$ZodCheck<string>;
-export declare class StringType extends BaseType<ZodMiniString<string>, ZodMiniString<string>> {
-    static factory(...checks: Check[]): StringType;
-    max(value: number): StringType;
-    min(value: number): StringType;
-    pattern(pattern: string | RegExp): StringType;
-    email(options?: core.$ZodEmailParams): StringType;
-    url(options?: core.$ZodURLParams): StringType;
-    ipv4(options?: core.$ZodIPv4Params): StringType;
-    ipv6(options?: core.$ZodIPv6Params): StringType;
-    uuid(options?: core.$ZodUUIDParams): StringType;
-    emoji(options?: core.$ZodEmojiParams): StringType;
-    nanoid(options?: core.$ZodNanoIDParams): StringType;
-    cuid(options?: core.$ZodCUIDParams): StringType;
-    cuid2(options?: core.$ZodCUID2Params): StringType;
-    e164(options?: core.$ZodE164Params): StringType;
-    jwt(options?: core.$ZodJWTParams): StringType;
-}
-export declare const string: typeof StringType.factory;
-export {};

package/dist/types/temporal.d.ts

@@ -1,26 +0,0 @@
-import type { Temporal } from 'temporal-spec';
-import type { ZodMiniString } from 'zod/mini';
-import { CustomType, TransformType } from './custom.ts';
-type EncodeType = ZodMiniString<string>;
-export declare class PlainDateType extends TransformType<Temporal.PlainDate, EncodeType> {
-    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainDate, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
-}
-export declare class PlainDateTimeType extends TransformType<Temporal.PlainDateTime, EncodeType> {
-    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
-}
-export declare class ZonedDateTimeType extends TransformType<Temporal.ZonedDateTime, EncodeType> {
-    static factory(implementation: typeof Temporal): CustomType<Temporal.ZonedDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
-}
-export declare class PlainTimeType extends TransformType<Temporal.PlainTime, EncodeType> {
-    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
-}
-export declare class DurationType extends TransformType<Temporal.Duration, EncodeType> {
-    static factory(implementation: typeof Temporal): CustomType<Temporal.Duration, EncodeType, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
-}
-export declare class PlainYearMonthType extends TransformType<Temporal.PlainYearMonth, EncodeType> {
-    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainYearMonth, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
-}
-export declare class PlainMonthDayType extends TransformType<Temporal.PlainMonthDay, EncodeType> {
-    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainMonthDay, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;
-}
-export {};

package/dist/types/tuple.d.ts

@@ -1,14 +0,0 @@
-import type { ArrayMap } from '@nmtjs/common';
-import type { ZodMiniTuple } from 'zod/mini';
-import type { ZodPlainType } from './_plain.ts';
-import { BaseType } from './base.ts';
-export declare class TupleType<T extends readonly [BaseType, ...BaseType[]] = readonly [
-    BaseType,
-    ...BaseType[]
-], R extends BaseType | null = BaseType | null> extends BaseType<R extends BaseType ? ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, R['encodeZodType']> : ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, null>, R extends BaseType ? ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, R['decodeZodType']> : ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, null>, {
-    elements: T;
-    rest?: R;
-}, R extends BaseType ? ZodPlainType<ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, R['encodeZodType']>> : ZodPlainType<ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, null>>, R extends BaseType ? ZodPlainType<ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, R['decodeZodType']>> : ZodPlainType<ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, null>>> {
-    static factory<T extends readonly [BaseType, ...BaseType[]], R extends BaseType | null = null>(elements: T, rest?: R): TupleType<T, R>;
-}
-export declare const tuple: typeof TupleType.factory;

package/dist/types/union.d.ts

@@ -1,42 +0,0 @@
-import type { ArrayMap } from '@nmtjs/common';
-import type { ZodMiniDiscriminatedUnion, ZodMiniIntersection, ZodMiniUnion } from 'zod/mini';
-import type { ZodPlainType } from './_plain.ts';
-import type { BaseTypeAny } from './base.ts';
-import type { LiteralType } from './literal.ts';
-import type { ObjectType, ObjectTypeProps } from './object.ts';
-import { BaseType } from './base.ts';
-export declare class UnionType<T extends readonly [BaseType, ...BaseType[]] = readonly [
-    BaseType,
-    ...BaseType[]
-]> extends BaseType<ZodMiniUnion<ArrayMap<T, 'encodeZodType'>>, ZodMiniUnion<ArrayMap<T, 'decodeZodType'>>, {
-    options: T;
-}, ZodPlainType<ZodMiniUnion<ArrayMap<T, 'encodeZodType'>>>, ZodPlainType<ZodMiniUnion<ArrayMap<T, 'decodeZodType'>>>> {
-    static factory<T extends readonly [BaseType, ...BaseType[]] = readonly [
-        BaseType,
-        ...BaseType[]
-    ]>(...options: T): UnionType<T>;
-}
-export declare class IntersactionType<T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType]> extends BaseType<ZodMiniIntersection<T[0]['encodeZodType'], T[1]['encodeZodType']>, ZodMiniIntersection<T[0]['decodeZodType'], T[1]['decodeZodType']>, {
-    options: T;
-}> {
-    static factory<T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType]>(...options: T): IntersactionType<T>;
-}
-export type DiscriminatedUnionProperties<K extends string = string> = {
-    [OK in K]: LiteralType<string>;
-} & {
-    [OK in string]: any;
-};
-export type DiscriminatedUnionOptionType<K extends string> = ObjectType<ObjectTypeProps & {
-    [_ in K]: BaseTypeAny;
-}>;
-export declare class DiscriminatedUnionType<K extends string = string, T extends readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[]> extends BaseType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodeZodType'>>, ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodeZodType'>>, {
-    key: K;
-    options: T;
-}, ZodPlainType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodeZodType'>>>, ZodPlainType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodeZodType'>>>> {
-    static factory<K extends string = string, T extends readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[]>(key: K, ...options: T): DiscriminatedUnionType<K, T>;
-}
-export declare const union: typeof UnionType.factory;
-export declare const or: typeof UnionType.factory;
-export declare const intersection: typeof IntersactionType.factory;
-export declare const and: typeof IntersactionType.factory;
-export declare const discriminatedUnion: typeof DiscriminatedUnionType.factory;