@nmtjs/type 0.14.0 → 0.14.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import * as type from './types/type.ts';
+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,6 +1,7 @@
-import * as zod from 'zod/mini';
-import * as type from "./types/type.js";
-zod.config(zod.core.locales.en());
+import { en } from 'zod/locales';
+import { config } from 'zod/mini';
+import * as type from "./types/_type.js";
+config(en());
 export * from "./types/base.js";
 export { type, type as t };
 export default type;

package/dist/types/{type.d.ts → _type.d.ts}

@@ -13,12 +13,12 @@ export * from './string.ts';
 export * from './tuple.ts';
 export * from './union.ts';
 export declare namespace infer {
-    namespace decoded {
-        type input<T extends BaseTypeAny> = T['decodedZodType']['_zod']['input'];
-        type output<T extends BaseTypeAny> = T['decodedZodType']['_zod']['output'];
+    namespace decode {
+        type input<T extends BaseTypeAny> = T['decodeZodType']['_zod']['input'];
+        type output<T extends BaseTypeAny> = T['decodeZodType']['_zod']['output'];
     }
-    namespace encoded {
-        type input<T extends BaseTypeAny> = T['encodedZodType']['_zod']['input'];
-        type output<T extends BaseTypeAny> = T['encodedZodType']['_zod']['output'];
+    namespace encode {
+        type input<T extends BaseTypeAny> = T['encodeZodType']['_zod']['input'];
+        type output<T extends BaseTypeAny> = T['encodeZodType']['_zod']['output'];
     }
 }

package/dist/types/any.d.ts

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

package/dist/types/any.js

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

package/dist/types/array.d.ts

@@ -1,7 +1,7 @@
-import * as zod from 'zod/mini';
+import type { core, ZodMiniArray } from 'zod/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']>, {
+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;
 }> {
     static factory<T extends BaseType>(element: T, ...checks: Check[]): ArrayType<T>;

package/dist/types/array.js

@@ -1,24 +1,24 @@
-import * as zod from 'zod/mini';
+import { length, maxLength, minLength, array as zodArray } from 'zod/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),
+            encodeZodType: zodArray(element.encodeZodType).check(...checks),
+            decodeZodType: zodArray(element.decodeZodType).check(...checks),
             params: { checks },
             props: { element },
         });
     }
     min(value) {
-        const check = zod.minLength(value);
+        const check = minLength(value);
         return ArrayType.factory(this.props.element, ...this.params.checks, check);
     }
     max(value) {
-        const check = zod.maxLength(value);
+        const check = maxLength(value);
         return ArrayType.factory(this.props.element, ...this.params.checks, check);
     }
     length(value) {
-        const check = zod.length(value);
+        const check = length(value);
         return ArrayType.factory(this.props.element, ...this.params.checks, check);
     }
 }

package/dist/types/base.d.ts

@@ -1,8 +1,9 @@
-import * as zod from 'zod/mini';
+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 = 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 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;
@@ -13,49 +14,49 @@ export type TypeMetadata<T = any> = {
 export type TypeParams = {
     encode?: (value: any) => any;
     metadata?: TypeMetadata;
-    checks: Array<zod.core.CheckFn<any> | zod.core.$ZodCheck<any>>;
+    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 = 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;
+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> {
+    readonly encodeZodType: EncodeZodType;
+    readonly decodeZodType: DecodeZodType;
     readonly props: Props;
     readonly params: TypeParams;
-    constructor({ encodedZodType, decodedZodType, props, params, }: {
-        encodedZodType: EncodedZodType;
-        decodedZodType?: DecodedZodType;
+    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['encodedZodType']['_zod']['input']): DefaultType<this>;
+    default(value: this['encodeZodType']['_zod']['input']): DefaultType<this>;
     title(title: string): this;
     description(description: string): this;
-    examples(...examples: this['encodedZodType']['_zod']['input'][]): this;
+    examples(...examples: this['encodeZodType']['_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'];
+    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<zod.ZodMiniOptional<Type['encodedZodType']>, zod.ZodMiniOptional<Type['decodedZodType']>, {
+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<zod.ZodMiniNullable<Type['encodedZodType']>, zod.ZodMiniNullable<Type['decodedZodType']>, {
+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<zod.ZodMiniDefault<Type['encodedZodType']>, zod.ZodMiniDefault<Type['decodedZodType']>, {
+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/base.js

@@ -1,14 +1,14 @@
-import * as zod from 'zod/mini';
-export const typesRegistry = zod.registry();
-export const NeemataTypeError = zod.core.$ZodError;
+import { _default, core, nullable, optional, registry } from 'zod/mini';
+export const typesRegistry = registry();
+export const NeemataTypeError = core.$ZodError;
 export class BaseType {
-    encodedZodType;
-    decodedZodType;
+    encodeZodType;
+    decodeZodType;
     props;
     params;
-    constructor({ encodedZodType, decodedZodType = encodedZodType, props = {}, params = {}, }) {
-        this.encodedZodType = encodedZodType;
-        this.decodedZodType = decodedZodType;
+    constructor({ encodeZodType, decodeZodType = encodeZodType, props = {}, params = {}, }) {
+        this.encodeZodType = encodeZodType;
+        this.decodeZodType = decodeZodType;
         this.props = props;
         this.params = Object.assign({ checks: [] }, params);
     }
@@ -38,22 +38,23 @@ export class BaseType {
         });
     }
     meta(newMetadata) {
-        const metadata = typesRegistry.get(this.encodedZodType) ?? {};
+        const metadata = typesRegistry.get(this.encodeZodType) ?? {};
         Object.assign(metadata, newMetadata);
-        typesRegistry.add(this.encodedZodType, metadata);
+        typesRegistry.add(this.encodeZodType, metadata);
         return this;
     }
-    encode(data) {
-        return this.encodedZodType.parse(data, { reportInput: true });
+    encode(data, context = {}) {
+        return this.encodeZodType.parse(data, { reportInput: true, ...context });
     }
-    decode(data) {
-        return this.decodedZodType.parse(data, { reportInput: true });
+    decode(data, context = {}) {
+        return this.decodeZodType.parse(data, { reportInput: true, ...context });
     }
 }
 export class OptionalType extends BaseType {
     static factory(type) {
         return new OptionalType({
-            encodedZodType: zod.optional(type.encodedZodType),
+            encodeZodType: optional(type.encodeZodType),
+            decodeZodType: optional(type.decodeZodType),
             props: { inner: type },
         });
     }
@@ -61,7 +62,8 @@ export class OptionalType extends BaseType {
 export class NullableType extends BaseType {
     static factory(type) {
         return new NullableType({
-            encodedZodType: zod.nullable(type.encodedZodType),
+            encodeZodType: nullable(type.encodeZodType),
+            decodeZodType: nullable(type.decodeZodType),
             props: { inner: type },
         });
     }
@@ -69,8 +71,8 @@ export class NullableType extends BaseType {
 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),
+            encodeZodType: _default(type.encodeZodType, type.params.encode?.(defaultValue) ?? defaultValue),
+            decodeZodType: _default(type.decodeZodType, defaultValue),
             props: { inner: type },
         });
     }

package/dist/types/boolean.d.ts

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

package/dist/types/boolean.js

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

package/dist/types/custom.d.ts

@@ -1,15 +1,15 @@
-import * as zod from 'zod/mini';
+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, 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 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, 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 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/custom.js

@@ -1,23 +1,14 @@
-import * as zod from 'zod/mini';
+import { any, overwrite, pipe, refine, 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 = zod.any(), }) {
+    static factory({ decode, encode, error, type = any(), }) {
         return new CustomType({
-            encodedZodType: zod.pipe(zod.custom().check(zod.refine((val) => typeof val !== 'undefined', {
-                error,
-                abort: true,
-            }), zod.overwrite(encode)), type),
+            encodeZodType: pipe(zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(encode)), type),
+            decodeZodType: pipe(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))),
+            zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(decode))),
             params: { encode },
         });
     }

package/dist/types/date.d.ts

@@ -1,6 +1,7 @@
-import * as zod from 'zod/mini';
+import type { ZodMiniUnion } from 'zod/mini';
+import { iso } from 'zod/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 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/date.js

@@ -1,11 +1,11 @@
-import * as zod from 'zod/mini';
+import { iso, union } from 'zod/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()]),
+            type: union([iso.date(), iso.datetime()]),
         });
     }
 }

package/dist/types/enum.d.ts

@@ -1,10 +1,10 @@
-import * as zod from 'zod/mini';
+import type { core, ZodMiniEnum } from 'zod/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>, {
+export declare class EnumType<T extends core.util.EnumLike = core.util.EnumLike> extends BaseType<ZodMiniEnum<T>, 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]>>;
+    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/enum.js

@@ -1,9 +1,9 @@
-import * as zod from 'zod/mini';
+import { enum as zodEnum } from 'zod/mini';
 import { BaseType } from "./base.js";
 export class EnumType extends BaseType {
     static factory(values) {
         return new EnumType({
-            encodedZodType: zod.enum(values),
+            encodeZodType: zodEnum(values),
             props: { values },
         });
     }

package/dist/types/literal.d.ts

@@ -1,7 +1,7 @@
-import * as zod from 'zod/mini';
+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<zod.ZodMiniLiteral<T>, zod.ZodMiniLiteral<T>, {
+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>;

package/dist/types/literal.js

@@ -1,9 +1,9 @@
-import * as zod from 'zod/mini';
+import { literal as zodLiteral } from 'zod/mini';
 import { BaseType } from "./base.js";
 export class LiteralType extends BaseType {
     static factory(value) {
         return new LiteralType({
-            encodedZodType: zod.literal(value),
+            encodeZodType: zodLiteral(value),
             props: { value },
         });
     }

package/dist/types/never.d.ts

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

package/dist/types/never.js

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

package/dist/types/number.d.ts

@@ -1,8 +1,8 @@
-import * as zod from 'zod/mini';
+import type { core, ZodMiniNumber, ZodMiniString } from 'zod/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>> {
+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;
@@ -14,8 +14,8 @@ export declare class NumberType extends BaseType<zod.ZodMiniNumber<number>, zod.
 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 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;

package/dist/types/number.js

@@ -1,35 +1,35 @@
-import * as zod from 'zod/mini';
+import { gt, gte, int, lt, lte, regex, number as zodNumber, string as zodString, } from 'zod/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),
+            encodeZodType: zodNumber().check(...checks),
             params: { checks },
         });
     }
     positive() {
-        return NumberType.factory(...this.params.checks, zod.gte(0));
+        return NumberType.factory(...this.params.checks, gte(0));
     }
     negative() {
-        return NumberType.factory(...this.params.checks, zod.lte(0));
+        return NumberType.factory(...this.params.checks, lte(0));
     }
     lt(value) {
-        return NumberType.factory(...this.params.checks, zod.lt(value));
+        return NumberType.factory(...this.params.checks, lt(value));
     }
     lte(value) {
-        return NumberType.factory(...this.params.checks, zod.lte(value));
+        return NumberType.factory(...this.params.checks, lte(value));
     }
     gte(value) {
-        return NumberType.factory(...this.params.checks, zod.gte(value));
+        return NumberType.factory(...this.params.checks, gte(value));
     }
     gt(value) {
-        return NumberType.factory(...this.params.checks, zod.gt(value));
+        return NumberType.factory(...this.params.checks, gt(value));
     }
 }
 export class IntegerType extends NumberType {
     static factory(...checks) {
-        return NumberType.factory(...checks, zod.int());
+        return NumberType.factory(...checks, int());
     }
 }
 export class BigIntType extends TransformType {
@@ -37,7 +37,7 @@ export class BigIntType extends TransformType {
         return CustomType.factory({
             decode: (value) => BigInt(value),
             encode: (value) => value.toString(),
-            type: zod.string().check(zod.regex(/^-?\d+$/)),
+            type: zodString().check(regex(/^-?\d+$/)),
             error: 'Invalid bigint format',
         });
     }

package/dist/types/object.d.ts

@@ -1,4 +1,4 @@
-import * as zod from 'zod/mini';
+import type { core, ZodMiniObject, ZodMiniRecord } from 'zod/mini';
 import type { BaseTypeAny, OptionalType } from './base.ts';
 import type { LiteralType } from './literal.ts';
 import type { StringType } from './string.ts';
@@ -8,19 +8,19 @@ export type ObjectTypeProps = {
     [k: string]: BaseTypeAny;
 };
 export type AnyObjectType = ObjectType<ObjectTypeProps>;
-export declare class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<zod.ZodMiniObject<{
-    [K in keyof T]: T[K]['encodedZodType'];
-}, zod.core.$strict>, zod.ZodMiniObject<{
-    [K in keyof T]: T[K]['decodedZodType'];
-}, zod.core.$strict>, {
+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;
 }> {
     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<zod.ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>, zod.ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>> {
+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']>> {
     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 ObjectType>(type: T): EnumType<zod.core.util.ToEnum<Extract<keyof T['props']['properties'], string>>>;
+export declare function keyof<T extends ObjectType>(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<{

package/dist/types/object.js

@@ -1,4 +1,4 @@
-import * as zod from 'zod/mini';
+import { object as zodObject, record as zodRecord } from 'zod/mini';
 import { BaseType } from "./base.js";
 import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
@@ -6,12 +6,12 @@ export class ObjectType extends BaseType {
         const encodeProperties = {};
         const decodeProperties = {};
         for (const key in properties) {
-            encodeProperties[key] = properties[key].encodedZodType;
-            decodeProperties[key] = properties[key].decodedZodType;
+            encodeProperties[key] = properties[key].encodeZodType;
+            decodeProperties[key] = properties[key].decodeZodType;
         }
         return new ObjectType({
-            encodedZodType: zod.object(encodeProperties),
-            decodedZodType: zod.object(decodeProperties),
+            encodeZodType: zodObject(encodeProperties),
+            decodeZodType: zodObject(decodeProperties),
             props: { properties },
         });
     }
@@ -19,8 +19,8 @@ export class ObjectType extends BaseType {
 export class RecordType extends BaseType {
     static factory(key, element) {
         return new RecordType({
-            encodedZodType: zod.record(key.encodedZodType, element.encodedZodType),
-            decodedZodType: zod.record(key.decodedZodType, element.decodedZodType),
+            encodeZodType: zodRecord(key.encodeZodType, element.encodeZodType),
+            decodeZodType: zodRecord(key.decodeZodType, element.decodeZodType),
             props: { key, element },
         });
     }

package/dist/types/string.d.ts

@@ -1,22 +1,22 @@
-import * as zod from 'zod/mini';
+import type { core, ZodMiniString } from 'zod/mini';
 import { BaseType } from './base.ts';
-type Check = zod.core.CheckFn<string> | zod.core.$ZodCheck<string>;
-export declare class StringType extends BaseType<zod.ZodMiniString<string>, zod.ZodMiniString<string>> {
+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?: zod.core.$ZodEmailParams): StringType;
-    url(options?: zod.core.$ZodURLParams): StringType;
-    ipv4(options?: zod.core.$ZodIPv4Params): StringType;
-    ipv6(options?: zod.core.$ZodIPv6Params): StringType;
-    uuid(options?: zod.core.$ZodUUIDParams): StringType;
-    emoji(options?: zod.core.$ZodEmojiParams): StringType;
-    nanoid(options?: zod.core.$ZodNanoIDParams): StringType;
-    cuid(options?: zod.core.$ZodCUIDParams): StringType;
-    cuid2(options?: zod.core.$ZodCUID2Params): StringType;
-    e164(options?: zod.core.$ZodE164Params): StringType;
-    jwt(options?: zod.core.$ZodJWTParams): 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/string.js

@@ -1,53 +1,53 @@
-import * as zod from 'zod/mini';
+import { cuid, cuid2, e164, email, emoji, ipv4, ipv6, jwt, maxLength, minLength, nanoid, regex, url, uuid, string as zodString, } from 'zod/mini';
 import { BaseType } from "./base.js";
 export class StringType extends BaseType {
     static factory(...checks) {
         return new StringType({
-            encodedZodType: zod.string().check(...checks),
+            encodeZodType: zodString().check(...checks),
             params: { checks },
         });
     }
     max(value) {
-        return StringType.factory(...this.params.checks, zod.maxLength(value));
+        return StringType.factory(...this.params.checks, maxLength(value));
     }
     min(value) {
-        return StringType.factory(...this.params.checks, zod.minLength(value));
+        return StringType.factory(...this.params.checks, minLength(value));
     }
     pattern(pattern) {
-        return StringType.factory(...this.params.checks, zod.regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern));
+        return StringType.factory(...this.params.checks, regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern));
     }
     email(options) {
-        return StringType.factory(...this.params.checks, zod.email(options));
+        return StringType.factory(...this.params.checks, email(options));
     }
     url(options) {
-        return StringType.factory(...this.params.checks, zod.url(options));
+        return StringType.factory(...this.params.checks, url(options));
     }
     ipv4(options) {
-        return StringType.factory(...this.params.checks, zod.ipv4(options));
+        return StringType.factory(...this.params.checks, ipv4(options));
     }
     ipv6(options) {
-        return StringType.factory(...this.params.checks, zod.ipv6(options));
+        return StringType.factory(...this.params.checks, ipv6(options));
     }
     uuid(options) {
-        return StringType.factory(...this.params.checks, zod.uuid(options));
+        return StringType.factory(...this.params.checks, uuid(options));
     }
     emoji(options) {
-        return StringType.factory(...this.params.checks, zod.emoji(options));
+        return StringType.factory(...this.params.checks, emoji(options));
     }
     nanoid(options) {
-        return StringType.factory(...this.params.checks, zod.nanoid(options));
+        return StringType.factory(...this.params.checks, nanoid(options));
     }
     cuid(options) {
-        return StringType.factory(...this.params.checks, zod.cuid(options));
+        return StringType.factory(...this.params.checks, cuid(options));
     }
     cuid2(options) {
-        return StringType.factory(...this.params.checks, zod.cuid2(options));
+        return StringType.factory(...this.params.checks, cuid2(options));
     }
     e164(options) {
-        return StringType.factory(...this.params.checks, zod.e164(options));
+        return StringType.factory(...this.params.checks, e164(options));
     }
     jwt(options) {
-        return StringType.factory(...this.params.checks, zod.jwt(options));
+        return StringType.factory(...this.params.checks, jwt(options));
     }
 }
 export const string = StringType.factory;

package/dist/types/temporal.d.ts

@@ -6,34 +6,34 @@ type TemporalTransformer<T extends Types> = {
     decode: (value: string) => ReturnType<(typeof Temporal)[T]['from']>;
     encode: (value: ReturnType<(typeof Temporal)[T]['from']>) => string;
 };
-type EncodedType = ZodMiniString<string>;
-export declare class PlainDateType extends TransformType<Temporal.PlainDate, EncodedType> {
+type EncodeType = ZodMiniString<string>;
+export declare class PlainDateType extends TransformType<Temporal.PlainDate, EncodeType> {
     static transformer: TemporalTransformer<"PlainDate">;
-    static factory(): CustomType<Temporal.PlainDate, EncodedType, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
+    static factory(): 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, EncodedType> {
+export declare class PlainDateTimeType extends TransformType<Temporal.PlainDateTime, EncodeType> {
     static transformer: TemporalTransformer<"PlainDateTime">;
-    static factory(): CustomType<Temporal.PlainDateTime, EncodedType, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
+    static factory(): 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, EncodedType> {
+export declare class ZonedDateTimeType extends TransformType<Temporal.ZonedDateTime, EncodeType> {
     static transformer: TemporalTransformer<"ZonedDateTime">;
-    static factory(): CustomType<Temporal.ZonedDateTime, EncodedType, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
+    static factory(): 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, EncodedType> {
+export declare class PlainTimeType extends TransformType<Temporal.PlainTime, EncodeType> {
     static transformer: TemporalTransformer<"PlainTime">;
-    static factory(): CustomType<Temporal.PlainTime, EncodedType, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
+    static factory(): 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, EncodedType> {
+export declare class DurationType extends TransformType<Temporal.Duration, EncodeType> {
     static transformer: TemporalTransformer<"Duration">;
-    static factory(): CustomType<Temporal.Duration, EncodedType, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
+    static factory(): 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, EncodedType> {
+export declare class PlainYearMonthType extends TransformType<Temporal.PlainYearMonth, EncodeType> {
     static transformer: TemporalTransformer<"PlainYearMonth">;
-    static factory(): CustomType<Temporal.PlainYearMonth, EncodedType, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
+    static factory(): 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, EncodedType> {
+export declare class PlainMonthDayType extends TransformType<Temporal.PlainMonthDay, EncodeType> {
     static transformer: TemporalTransformer<"PlainMonthDay">;
-    static factory(): CustomType<Temporal.PlainMonthDay, EncodedType, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;
+    static factory(): CustomType<Temporal.PlainMonthDay, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;
 }
 export declare const plainDate: typeof PlainDateType.factory;
 export declare const plainDatetime: typeof PlainDateTimeType.factory;

package/dist/types/tuple.d.ts

@@ -1,10 +1,10 @@
 import type { ArrayMap } from '@nmtjs/common';
-import * as zod from 'zod/mini';
+import type { ZodMiniTuple } from 'zod/mini';
 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 ? zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, R['encodedZodType']> : zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, null>, R extends BaseType ? zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, R['decodedZodType']> : zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, null>, {
+], 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;
 }> {

package/dist/types/tuple.js

@@ -1,14 +1,14 @@
-import * as zod from 'zod/mini';
+import { tuple as zodTuple } from 'zod/mini';
 import { BaseType } from "./base.js";
 export class TupleType extends BaseType {
     static factory(elements, rest = null) {
-        const encoded = elements.map((el) => el.encodedZodType);
-        const decoded = elements.map((el) => el.decodedZodType);
+        const encode = elements.map((el) => el.encodeZodType);
+        const decode = elements.map((el) => el.decodeZodType);
         return new TupleType({
             // @ts-expect-error
-            encodedZodType: zod.tuple(encoded, rest?.encodedZodType),
+            encodeZodType: zodTuple(encode, rest?.encodeZodType),
             // @ts-expect-error
-            decodedZodType: zod.tuple(decoded, rest?.decodedZodType),
+            decodeZodType: zodTuple(decode, rest?.decodeZodType),
             props: { elements, rest },
         });
     }

package/dist/types/union.d.ts

@@ -1,5 +1,5 @@
 import type { ArrayMap } from '@nmtjs/common';
-import * as zod from 'zod/mini';
+import type { ZodMiniDiscriminatedUnion, ZodMiniIntersection, ZodMiniUnion } from 'zod/mini';
 import type { BaseTypeAny } from './base.ts';
 import type { LiteralType } from './literal.ts';
 import type { ObjectType, ObjectTypeProps } from './object.ts';
@@ -7,7 +7,7 @@ import { BaseType } from './base.ts';
 export declare class UnionType<T extends readonly [BaseType, ...BaseType[]] = readonly [
     BaseType,
     ...BaseType[]
-]> extends BaseType<zod.ZodMiniUnion<ArrayMap<T, 'encodedZodType'>>, zod.ZodMiniUnion<ArrayMap<T, 'decodedZodType'>>, {
+]> extends BaseType<ZodMiniUnion<ArrayMap<T, 'encodeZodType'>>, ZodMiniUnion<ArrayMap<T, 'decodeZodType'>>, {
     options: T;
 }> {
     static factory<T extends readonly [BaseType, ...BaseType[]] = readonly [
@@ -15,7 +15,7 @@ export declare class UnionType<T extends readonly [BaseType, ...BaseType[]] = re
         ...BaseType[]
     ]>(...options: T): UnionType<T>;
 }
-export declare class IntersactionType<T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType]> extends BaseType<zod.ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>, zod.ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>, {
+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>;
@@ -28,7 +28,7 @@ export type DiscriminatedUnionProperties<K extends string = string> = {
 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<zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodedZodType'>>, zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodedZodType'>>, {
+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;
 }> {

package/dist/types/union.js

@@ -1,12 +1,12 @@
-import * as zod from 'zod/mini';
+import { discriminatedUnion as zodDiscriminatedUnion, intersection as zodIntersection, union as zodUnion, } from 'zod/mini';
 import { BaseType } from "./base.js";
 export class UnionType extends BaseType {
     static factory(...options) {
-        const encoded = options.map((t) => t.encodedZodType);
-        const decoded = options.map((t) => t.decodedZodType);
+        const encode = options.map((t) => t.encodeZodType);
+        const decode = options.map((t) => t.decodeZodType);
         return new UnionType({
-            encodedZodType: zod.union(encoded),
-            decodedZodType: zod.union(decoded),
+            encodeZodType: zodUnion(encode),
+            decodeZodType: zodUnion(decode),
             props: { options },
         });
     }
@@ -15,21 +15,21 @@ export class IntersactionType extends BaseType {
     static factory(...options) {
         const [first, second] = options;
         return new IntersactionType({
-            encodedZodType: zod.intersection(first.encodedZodType, second.encodedZodType),
-            decodedZodType: zod.intersection(first.decodedZodType, second.decodedZodType),
+            encodeZodType: zodIntersection(first.encodeZodType, second.encodeZodType),
+            decodeZodType: zodIntersection(first.decodeZodType, second.decodeZodType),
             props: { options },
         });
     }
 }
 export class DiscriminatedUnionType extends BaseType {
     static factory(key, ...options) {
-        const encoded = options.map((t) => t.encodedZodType);
-        const decoded = options.map((t) => t.decodedZodType);
+        const encode = options.map((t) => t.encodeZodType);
+        const decode = options.map((t) => t.decodeZodType);
         return new DiscriminatedUnionType({
             // @ts-expect-error
-            encodedZodType: zod.discriminatedUnion(key, encoded),
+            encodeZodType: zodDiscriminatedUnion(key, encode),
             // @ts-expect-error
-            decodedZodType: zod.discriminatedUnion(key, decoded),
+            decodeZodType: zodDiscriminatedUnion(key, decode),
             props: { key, options },
         });
     }

package/package.json

@@ -21,19 +21,19 @@
   "peerDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.0"
+    "@nmtjs/common": "0.14.2"
   },
   "devDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.0"
+    "@nmtjs/common": "0.14.2"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.0",
+  "version": "0.14.2",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"