@nmtjs/type 0.12.4 → 0.12.6

package/dist/types/object.d.ts

@@ -0,0 +1,43 @@
+import * as zod from 'zod/v4-mini';
+import { BaseType, type BaseTypeAny, type OptionalType } from './base.ts';
+import { EnumType } from './enum.ts';
+import type { LiteralType } from './literal.ts';
+import type { StringType } from './string.ts';
+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>, {
+    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']>> {
+    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 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/object.js

@@ -1,64 +1,59 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-mini';
 import { BaseType } from "./base.js";
 import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
-	static factory(properties) {
-		const encodeProperties = {};
-		const decodeProperties = {};
-		for (const key in properties) {
-			encodeProperties[key] = properties[key].encodedZodType;
-			decodeProperties[key] = properties[key].decodedZodType;
-		}
-		return new ObjectType({
-			encodedZodType: zod.object(encodeProperties),
-			decodedZodType: zod.object(decodeProperties),
-			props: { properties }
-		});
-	}
+    static factory(properties) {
+        const encodeProperties = {};
+        const decodeProperties = {};
+        for (const key in properties) {
+            encodeProperties[key] = properties[key].encodedZodType;
+            decodeProperties[key] = properties[key].decodedZodType;
+        }
+        return new ObjectType({
+            encodedZodType: zod.object(encodeProperties),
+            decodedZodType: zod.object(decodeProperties),
+            props: { properties },
+        });
+    }
 }
 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),
-			props: {
-				key,
-				element
-			}
-		});
-	}
+    static factory(key, element) {
+        return new RecordType({
+            encodedZodType: zod.record(key.encodedZodType, element.encodedZodType),
+            decodedZodType: zod.record(key.decodedZodType, element.decodedZodType),
+            props: { key, element },
+        });
+    }
 }
 export function keyof(type) {
-	return EnumType.factory(Object.keys(type.props.properties));
+    return EnumType.factory(Object.keys(type.props.properties));
 }
 export function pick(source, pick) {
-	const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key]) => pick[key]));
-	return ObjectType.factory(properties);
+    const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key]) => pick[key]));
+    return ObjectType.factory(properties);
 }
 export function omit(source, omit) {
-	const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key]) => !omit[key]));
-	return ObjectType.factory(properties);
+    const properties = Object.fromEntries(Object.entries(source.props.properties).filter(([key]) => !omit[key]));
+    return ObjectType.factory(properties);
 }
 export function extend(object1, properties) {
-	return ObjectType.factory({
-		...object1.props.properties,
-		...properties
-	});
+    return ObjectType.factory({
+        ...object1.props.properties,
+        ...properties,
+    });
 }
 export function merge(object1, object2) {
-	return ObjectType.factory({
-		...object1.props.properties,
-		...object2.props.properties
-	});
+    return ObjectType.factory({
+        ...object1.props.properties,
+        ...object2.props.properties,
+    });
 }
 export function partial(object) {
-	const properties = {};
-	for (const [key, value] of Object.entries(object.props.properties)) {
-		properties[key] = value.optional();
-	}
-	return ObjectType.factory(properties);
+    const properties = {};
+    for (const [key, value] of Object.entries(object.props.properties)) {
+        properties[key] = value.optional();
+    }
+    return ObjectType.factory(properties);
 }
 export const object = ObjectType.factory;
 export const record = RecordType.factory;
-
-//# sourceMappingURL=object.js.map

package/dist/types/string.d.ts

@@ -0,0 +1,22 @@
+import * as zod from 'zod/v4-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>> {
+    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;
+}
+export declare const string: typeof StringType.factory;
+export {};

package/dist/types/string.js

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

package/dist/types/temporal.d.ts

@@ -0,0 +1,45 @@
+import { Temporal } from 'temporal-polyfill';
+import { type ZodMiniString } from 'zod/v4-mini';
+import { CustomType, TransformType } from './custom.ts';
+type Types = Exclude<keyof typeof Temporal, 'Now' | 'Instant' | 'Calendar' | 'TimeZone'>;
+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> {
+    static transformer: TemporalTransformer<"PlainDate">;
+    static factory(): CustomType<Temporal.PlainDate, EncodedType, import("zod/v4-mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
+}
+export declare class PlainDateTimeType extends TransformType<Temporal.PlainDateTime, EncodedType> {
+    static transformer: TemporalTransformer<"PlainDateTime">;
+    static factory(): CustomType<Temporal.PlainDateTime, EncodedType, import("zod/v4-mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
+}
+export declare class ZonedDateTimeType extends TransformType<Temporal.ZonedDateTime, EncodedType> {
+    static transformer: TemporalTransformer<"ZonedDateTime">;
+    static factory(): CustomType<Temporal.ZonedDateTime, EncodedType, import("zod/v4-mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
+}
+export declare class PlainTimeType extends TransformType<Temporal.PlainTime, EncodedType> {
+    static transformer: TemporalTransformer<"PlainTime">;
+    static factory(): CustomType<Temporal.PlainTime, EncodedType, import("zod/v4-mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
+}
+export declare class DurationType extends TransformType<Temporal.Duration, EncodedType> {
+    static transformer: TemporalTransformer<"Duration">;
+    static factory(): CustomType<Temporal.Duration, EncodedType, import("zod/v4-mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
+}
+export declare class PlainYearMonthType extends TransformType<Temporal.PlainYearMonth, EncodedType> {
+    static transformer: TemporalTransformer<"PlainYearMonth">;
+    static factory(): CustomType<Temporal.PlainYearMonth, EncodedType, import("zod/v4-mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
+}
+export declare class PlainMonthDayType extends TransformType<Temporal.PlainMonthDay, EncodedType> {
+    static transformer: TemporalTransformer<"PlainMonthDay">;
+    static factory(): CustomType<Temporal.PlainMonthDay, EncodedType, import("zod/v4-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;
+export declare const plainTime: typeof PlainTimeType.factory;
+export declare const zonedDatetime: typeof ZonedDateTimeType.factory;
+export declare const duration: typeof DurationType.factory;
+export declare const plainYearMonth: typeof PlainYearMonthType.factory;
+export declare const plainMonthDay: typeof PlainMonthDayType.factory;
+export {};

package/dist/types/temporal.js

@@ -1,93 +1,93 @@
-import { Temporal } from "temporal-polyfill";
-import { iso, regex, string } from "zod/v4-mini";
+import { Temporal } from 'temporal-polyfill';
+import { iso, regex, string } from 'zod/v4-mini';
 import { CustomType, TransformType } from "./custom.js";
 const createTemporalTransformer = (type, decode = (value) => Temporal[type].from(value)) => {
-	const encode = (value) => value.toString({
-		calendarName: "never",
-		smallestUnit: "microsecond",
-		timeZoneName: "never"
-	});
-	return {
-		decode,
-		encode
-	};
+    const encode = (value) => value.toString({
+        calendarName: 'never',
+        smallestUnit: 'microsecond',
+        timeZoneName: 'never',
+    });
+    return {
+        decode,
+        encode,
+    };
 };
 export class PlainDateType extends TransformType {
-	static transformer = createTemporalTransformer("PlainDate");
-	static factory() {
-		return CustomType.factory({
-			decode: PlainDateType.transformer.decode,
-			encode: PlainDateType.transformer.encode,
-			type: iso.date(),
-			error: "Invalid date format"
-		});
-	}
+    static transformer = createTemporalTransformer('PlainDate');
+    static factory() {
+        return CustomType.factory({
+            decode: PlainDateType.transformer.decode,
+            encode: PlainDateType.transformer.encode,
+            type: iso.date(),
+            error: 'Invalid date format',
+        });
+    }
 }
 export class PlainDateTimeType extends TransformType {
-	static transformer = createTemporalTransformer("PlainDateTime");
-	static factory() {
-		return CustomType.factory({
-			decode: PlainDateTimeType.transformer.decode,
-			encode: PlainDateTimeType.transformer.encode,
-			type: iso.datetime({ local: true }),
-			error: "Invalid datetime format"
-		});
-	}
+    static transformer = createTemporalTransformer('PlainDateTime');
+    static factory() {
+        return CustomType.factory({
+            decode: PlainDateTimeType.transformer.decode,
+            encode: PlainDateTimeType.transformer.encode,
+            type: iso.datetime({ local: true }),
+            error: 'Invalid datetime format',
+        });
+    }
 }
 export class ZonedDateTimeType extends TransformType {
-	static transformer = createTemporalTransformer("ZonedDateTime", (value) => Temporal.Instant.from(value).toZonedDateTimeISO("UTC"));
-	static factory() {
-		return CustomType.factory({
-			decode: ZonedDateTimeType.transformer.decode,
-			encode: ZonedDateTimeType.transformer.encode,
-			type: iso.datetime({ local: true }),
-			error: "Invalid datetime format"
-		});
-	}
+    static transformer = createTemporalTransformer('ZonedDateTime', (value) => Temporal.Instant.from(value).toZonedDateTimeISO('UTC'));
+    static factory() {
+        return CustomType.factory({
+            decode: ZonedDateTimeType.transformer.decode,
+            encode: ZonedDateTimeType.transformer.encode,
+            type: iso.datetime({ local: true }),
+            error: 'Invalid datetime format',
+        });
+    }
 }
 export class PlainTimeType extends TransformType {
-	static transformer = createTemporalTransformer("PlainTime");
-	static factory() {
-		return CustomType.factory({
-			decode: PlainTimeType.transformer.decode,
-			encode: PlainTimeType.transformer.encode,
-			type: iso.time(),
-			error: "Invalid time format"
-		});
-	}
+    static transformer = createTemporalTransformer('PlainTime');
+    static factory() {
+        return CustomType.factory({
+            decode: PlainTimeType.transformer.decode,
+            encode: PlainTimeType.transformer.encode,
+            type: iso.time(),
+            error: 'Invalid time format',
+        });
+    }
 }
 export class DurationType extends TransformType {
-	static transformer = createTemporalTransformer("Duration");
-	static factory() {
-		return CustomType.factory({
-			decode: DurationType.transformer.decode,
-			encode: DurationType.transformer.encode,
-			type: iso.duration(),
-			error: "Invalid duration format"
-		});
-	}
+    static transformer = createTemporalTransformer('Duration');
+    static factory() {
+        return CustomType.factory({
+            decode: DurationType.transformer.decode,
+            encode: DurationType.transformer.encode,
+            type: iso.duration(),
+            error: 'Invalid duration format',
+        });
+    }
 }
 export class PlainYearMonthType extends TransformType {
-	static transformer = createTemporalTransformer("PlainYearMonth");
-	static factory() {
-		return CustomType.factory({
-			decode: PlainYearMonthType.transformer.decode,
-			encode: PlainYearMonthType.transformer.encode,
-			type: string().check(regex(/^\d{4}-\d{2}$/)),
-			error: "Invalid year-month format"
-		});
-	}
+    static transformer = createTemporalTransformer('PlainYearMonth');
+    static factory() {
+        return CustomType.factory({
+            decode: PlainYearMonthType.transformer.decode,
+            encode: PlainYearMonthType.transformer.encode,
+            type: string().check(regex(/^\d{4}-\d{2}$/)),
+            error: 'Invalid year-month format',
+        });
+    }
 }
 export class PlainMonthDayType extends TransformType {
-	static transformer = createTemporalTransformer("PlainMonthDay");
-	static factory() {
-		return CustomType.factory({
-			decode: PlainMonthDayType.transformer.decode,
-			encode: PlainMonthDayType.transformer.encode,
-			type: string().check(regex(/^\d{2}-\d{2}$/)),
-			error: "Invalid month-day format"
-		});
-	}
+    static transformer = createTemporalTransformer('PlainMonthDay');
+    static factory() {
+        return CustomType.factory({
+            decode: PlainMonthDayType.transformer.decode,
+            encode: PlainMonthDayType.transformer.encode,
+            type: string().check(regex(/^\d{2}-\d{2}$/)),
+            error: 'Invalid month-day format',
+        });
+    }
 }
 export const plainDate = PlainDateType.factory;
 export const plainDatetime = PlainDateTimeType.factory;
@@ -96,5 +96,3 @@ export const zonedDatetime = ZonedDateTimeType.factory;
 export const duration = DurationType.factory;
 export const plainYearMonth = PlainYearMonthType.factory;
 export const plainMonthDay = PlainMonthDayType.factory;
-
-//# sourceMappingURL=temporal.js.map

package/dist/types/tuple.d.ts

@@ -0,0 +1,13 @@
+import type { ArrayMap } from '@nmtjs/common';
+import * as zod from 'zod/v4-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>, {
+    elements: T;
+    rest?: R;
+}> {
+    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/tuple.js

@@ -1,19 +1,16 @@
-import * as zod from "zod/v4-mini";
+import * as zod from 'zod/v4-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);
-		return new TupleType({
-			encodedZodType: zod.tuple(encoded, rest?.encodedZodType),
-			decodedZodType: zod.tuple(decoded, rest?.decodedZodType),
-			props: {
-				elements,
-				rest
-			}
-		});
-	}
+    static factory(elements, rest = null) {
+        const encoded = elements.map((el) => el.encodedZodType);
+        const decoded = elements.map((el) => el.decodedZodType);
+        return new TupleType({
+            // @ts-expect-error
+            encodedZodType: zod.tuple(encoded, rest?.encodedZodType),
+            // @ts-expect-error
+            decodedZodType: zod.tuple(decoded, rest?.decodedZodType),
+            props: { elements, rest },
+        });
+    }
 }
 export const tuple = TupleType.factory;
-
-//# sourceMappingURL=tuple.js.map

package/dist/types/type.d.ts

@@ -0,0 +1,24 @@
+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 decoded {
+        type input<T extends BaseTypeAny> = T['decodedZodType']['_zod']['input'];
+        type output<T extends BaseTypeAny> = T['decodedZodType']['_zod']['output'];
+    }
+    namespace encoded {
+        type input<T extends BaseTypeAny> = T['encodedZodType']['_zod']['input'];
+        type output<T extends BaseTypeAny> = T['encodedZodType']['_zod']['output'];
+    }
+}

package/dist/types/type.js

@@ -11,5 +11,3 @@ export * from "./object.js";
 export * from "./string.js";
 export * from "./tuple.js";
 export * from "./union.js";
-
-//# sourceMappingURL=type.js.map

package/dist/types/union.d.ts

@@ -0,0 +1,40 @@
+import type { ArrayMap } from '@nmtjs/common';
+import * as zod from 'zod/v4-mini';
+import { BaseType, type BaseTypeAny } from './base.ts';
+import type { LiteralType } from './literal.ts';
+import type { ObjectType, ObjectTypeProps } from './object.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'>>, {
+    options: T;
+}> {
+    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<zod.ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>, zod.ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>, {
+    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<zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodedZodType'>>, zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodedZodType'>>, {
+    key: K;
+    options: T;
+}> {
+    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;