@nmtjs/type 0.14.4 → 0.15.0-beta.1

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/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.4"
+    "zod": "^4.1.0",
+    "@nmtjs/common": "0.15.0-beta.1"
   },
   "devDependencies": {
     "temporal-polyfill": "^0.3.0",
-    "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.4"
+    "zod": "^4.1.0",
+    "@nmtjs/common": "0.15.0-beta.1"
   },
   "peerDependenciesMeta": {
     "temporal-polyfill": {
       "optional": true
     }
   },
-  "version": "0.14.4",
+  "version": "0.15.0-beta.1",
   "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/index.js

@@ -1,7 +0,0 @@
-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/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/global.js

@@ -1,9 +0,0 @@
-import 'temporal-spec/global';
-import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from "../types/temporal.js";
-export const plainDate = PlainDateType.factory.bind(PlainDateType, Temporal);
-export const plainDatetime = PlainDateTimeType.factory.bind(PlainDateTimeType, Temporal);
-export const plainTime = PlainTimeType.factory.bind(PlainTimeType, Temporal);
-export const zonedDatetime = ZonedDateTimeType.factory.bind(ZonedDateTimeType, Temporal);
-export const duration = DurationType.factory.bind(DurationType, Temporal);
-export const plainYearMonth = PlainYearMonthType.factory.bind(PlainYearMonthType, Temporal);
-export const plainMonthDay = PlainMonthDayType.factory.bind(PlainMonthDayType, Temporal);

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/temporal/polyfill.js

@@ -1,9 +0,0 @@
-import { Temporal } from 'temporal-polyfill';
-import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from "../types/temporal.js";
-export const plainDate = PlainDateType.factory.bind(PlainDateType, Temporal);
-export const plainDatetime = PlainDateTimeType.factory.bind(PlainDateTimeType, Temporal);
-export const plainTime = PlainTimeType.factory.bind(PlainTimeType, Temporal);
-export const zonedDatetime = ZonedDateTimeType.factory.bind(ZonedDateTimeType, Temporal);
-export const duration = DurationType.factory.bind(DurationType, Temporal);
-export const plainYearMonth = PlainYearMonthType.factory.bind(PlainYearMonthType, Temporal);
-export const plainMonthDay = PlainMonthDayType.factory.bind(PlainMonthDayType, Temporal);

package/dist/types/_type.d.ts

@@ -1,24 +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'];
-    }
-}

package/dist/types/_type.js

@@ -1,13 +0,0 @@
-export * from "./any.js";
-export * from "./array.js";
-export * from "./boolean.js";
-export * from "./custom.js";
-export * from "./date.js";
-export * from "./enum.js";
-export * from "./literal.js";
-export * from "./never.js";
-export * from "./number.js";
-export * from "./object.js";
-export * from "./string.js";
-export * from "./tuple.js";
-export * from "./union.js";

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/any.js

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

package/dist/types/array.d.ts

@@ -1,13 +0,0 @@
-import type { core, ZodMiniArray } from 'zod/mini';
-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;
-}> {
-    static factory<T extends BaseType>(element: T, ...checks: Check[]): ArrayType<T>;
-    min(value: number): ArrayType<T>;
-    max(value: number): ArrayType<T>;
-    length(value: number): ArrayType<T>;
-}
-export declare const array: typeof ArrayType.factory;
-export {};

package/dist/types/array.js

@@ -1,25 +0,0 @@
-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({
-            encodeZodType: zodArray(element.encodeZodType).check(...checks),
-            decodeZodType: zodArray(element.decodeZodType).check(...checks),
-            params: { checks },
-            props: { element },
-        });
-    }
-    min(value) {
-        const check = minLength(value);
-        return ArrayType.factory(this.props.element, ...this.params.checks, check);
-    }
-    max(value) {
-        const check = maxLength(value);
-        return ArrayType.factory(this.props.element, ...this.params.checks, check);
-    }
-    length(value) {
-        const check = length(value);
-        return ArrayType.factory(this.props.element, ...this.params.checks, check);
-    }
-}
-export const array = ArrayType.factory;

package/dist/types/base.d.ts

@@ -1,63 +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> {
-    readonly encodeZodType: EncodeZodType;
-    readonly decodeZodType: DecodeZodType;
-    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/base.js

@@ -1,79 +0,0 @@
-import { _default, core, nullable, optional, registry } from 'zod/mini';
-export const typesRegistry = registry();
-export const NeemataTypeError = core.$ZodError;
-export class BaseType {
-    encodeZodType;
-    decodeZodType;
-    props;
-    params;
-    constructor({ encodeZodType, decodeZodType = encodeZodType, props = {}, params = {}, }) {
-        this.encodeZodType = encodeZodType;
-        this.decodeZodType = decodeZodType;
-        this.props = props;
-        this.params = Object.assign({ checks: [] }, params);
-    }
-    optional() {
-        return OptionalType.factory(this);
-    }
-    nullable() {
-        return NullableType.factory(this);
-    }
-    nullish() {
-        return this.nullable().optional();
-    }
-    default(value) {
-        return DefaultType.factory(this, value);
-    }
-    title(title) {
-        return this.meta({ title });
-    }
-    description(description) {
-        return this.meta({ description });
-    }
-    examples(...examples) {
-        return this.meta({
-            examples: this.params.encode
-                ? examples.map(this.params.encode)
-                : examples,
-        });
-    }
-    meta(newMetadata) {
-        const metadata = typesRegistry.get(this.encodeZodType) ?? {};
-        Object.assign(metadata, newMetadata);
-        typesRegistry.add(this.encodeZodType, metadata);
-        return this;
-    }
-    encode(data, context = {}) {
-        return this.encodeZodType.parse(data, { reportInput: true, ...context });
-    }
-    decode(data, context = {}) {
-        return this.decodeZodType.parse(data, { reportInput: true, ...context });
-    }
-}
-export class OptionalType extends BaseType {
-    static factory(type) {
-        return new OptionalType({
-            encodeZodType: optional(type.encodeZodType),
-            decodeZodType: optional(type.decodeZodType),
-            props: { inner: type },
-        });
-    }
-}
-export class NullableType extends BaseType {
-    static factory(type) {
-        return new NullableType({
-            encodeZodType: nullable(type.encodeZodType),
-            decodeZodType: nullable(type.decodeZodType),
-            props: { inner: type },
-        });
-    }
-}
-export class DefaultType extends BaseType {
-    static factory(type, defaultValue) {
-        return new DefaultType({
-            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 +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/boolean.js

@@ -1,8 +0,0 @@
-import { boolean as zodBoolean } from 'zod/mini';
-import { BaseType } from "./base.js";
-export class BooleanType extends BaseType {
-    static factory() {
-        return new BooleanType({ encodeZodType: zodBoolean() });
-    }
-}
-export const boolean = 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/custom.js

@@ -1,16 +0,0 @@
-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 = any(), }) {
-        return new CustomType({
-            encodeZodType: pipe(zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(encode)), type),
-            decodeZodType: pipe(type, 
-            // @ts-expect-error
-            zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(decode))),
-            params: { encode },
-        });
-    }
-}
-export const custom = 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/date.js

@@ -1,12 +0,0 @@
-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: union([iso.date(), iso.datetime()]),
-        });
-    }
-}
-export const date = 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/enum.js

@@ -1,12 +0,0 @@
-import { enum as zodEnum } from 'zod/mini';
-import { BaseType } from "./base.js";
-export class EnumType extends BaseType {
-    static factory(values) {
-        return new EnumType({
-            encodeZodType: zodEnum(values),
-            props: { values },
-        });
-    }
-}
-const _enum = 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/literal.js

@@ -1,11 +0,0 @@
-import { literal as zodLiteral } from 'zod/mini';
-import { BaseType } from "./base.js";
-export class LiteralType extends BaseType {
-    static factory(value) {
-        return new LiteralType({
-            encodeZodType: zodLiteral(value),
-            props: { value },
-        });
-    }
-}
-export const literal = 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/never.js

@@ -1,8 +0,0 @@
-import { never as zodNever } from 'zod/mini';
-import { BaseType } from "./base.js";
-export class NeverType extends BaseType {
-    static factory() {
-        return new NeverType({ encodeZodType: zodNever() });
-    }
-}
-export const never = 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/number.js

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

package/dist/types/object.d.ts

@@ -1,44 +0,0 @@
-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';
-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;
-}> {
-    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']>> {
-    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<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,59 +0,0 @@
-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 {
-    static factory(properties) {
-        const encodeProperties = {};
-        const decodeProperties = {};
-        for (const key in properties) {
-            encodeProperties[key] = properties[key].encodeZodType;
-            decodeProperties[key] = properties[key].decodeZodType;
-        }
-        return new ObjectType({
-            encodeZodType: zodObject(encodeProperties),
-            decodeZodType: zodObject(decodeProperties),
-            props: { properties },
-        });
-    }
-}
-export class RecordType extends BaseType {
-    static factory(key, element) {
-        return new RecordType({
-            encodeZodType: zodRecord(key.encodeZodType, element.encodeZodType),
-            decodeZodType: zodRecord(key.decodeZodType, element.decodeZodType),
-            props: { key, element },
-        });
-    }
-}
-export function keyof(type) {
-    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);
-}
-export function omit(source, omit) {
-    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,
-    });
-}
-export function merge(object1, object2) {
-    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);
-}
-export const object = ObjectType.factory;
-export const record = 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/string.js

@@ -1,53 +0,0 @@
-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({
-            encodeZodType: zodString().check(...checks),
-            params: { checks },
-        });
-    }
-    max(value) {
-        return StringType.factory(...this.params.checks, maxLength(value));
-    }
-    min(value) {
-        return StringType.factory(...this.params.checks, minLength(value));
-    }
-    pattern(pattern) {
-        return StringType.factory(...this.params.checks, regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern));
-    }
-    email(options) {
-        return StringType.factory(...this.params.checks, email(options));
-    }
-    url(options) {
-        return StringType.factory(...this.params.checks, url(options));
-    }
-    ipv4(options) {
-        return StringType.factory(...this.params.checks, ipv4(options));
-    }
-    ipv6(options) {
-        return StringType.factory(...this.params.checks, ipv6(options));
-    }
-    uuid(options) {
-        return StringType.factory(...this.params.checks, uuid(options));
-    }
-    emoji(options) {
-        return StringType.factory(...this.params.checks, emoji(options));
-    }
-    nanoid(options) {
-        return StringType.factory(...this.params.checks, nanoid(options));
-    }
-    cuid(options) {
-        return StringType.factory(...this.params.checks, cuid(options));
-    }
-    cuid2(options) {
-        return StringType.factory(...this.params.checks, cuid2(options));
-    }
-    e164(options) {
-        return StringType.factory(...this.params.checks, e164(options));
-    }
-    jwt(options) {
-        return StringType.factory(...this.params.checks, jwt(options));
-    }
-}
-export const string = StringType.factory;

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/temporal.js

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

package/dist/types/tuple.d.ts

@@ -1,13 +0,0 @@
-import type { ArrayMap } from '@nmtjs/common';
-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 ? 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;
-}> {
-    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,16 +0,0 @@
-import { tuple as zodTuple } from 'zod/mini';
-import { BaseType } from "./base.js";
-export class TupleType extends BaseType {
-    static factory(elements, rest = null) {
-        const encode = elements.map((el) => el.encodeZodType);
-        const decode = elements.map((el) => el.decodeZodType);
-        return new TupleType({
-            // @ts-expect-error
-            encodeZodType: zodTuple(encode, rest?.encodeZodType),
-            // @ts-expect-error
-            decodeZodType: zodTuple(decode, rest?.decodeZodType),
-            props: { elements, rest },
-        });
-    }
-}
-export const tuple = TupleType.factory;

package/dist/types/union.d.ts

@@ -1,41 +0,0 @@
-import type { ArrayMap } from '@nmtjs/common';
-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';
-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;
-}> {
-    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;
-}> {
-    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;

package/dist/types/union.js

@@ -1,41 +0,0 @@
-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 encode = options.map((t) => t.encodeZodType);
-        const decode = options.map((t) => t.decodeZodType);
-        return new UnionType({
-            encodeZodType: zodUnion(encode),
-            decodeZodType: zodUnion(decode),
-            props: { options },
-        });
-    }
-}
-export class IntersactionType extends BaseType {
-    static factory(...options) {
-        const [first, second] = options;
-        return new IntersactionType({
-            encodeZodType: zodIntersection(first.encodeZodType, second.encodeZodType),
-            decodeZodType: zodIntersection(first.decodeZodType, second.decodeZodType),
-            props: { options },
-        });
-    }
-}
-export class DiscriminatedUnionType extends BaseType {
-    static factory(key, ...options) {
-        const encode = options.map((t) => t.encodeZodType);
-        const decode = options.map((t) => t.decodeZodType);
-        return new DiscriminatedUnionType({
-            // @ts-expect-error
-            encodeZodType: zodDiscriminatedUnion(key, encode),
-            // @ts-expect-error
-            decodeZodType: zodDiscriminatedUnion(key, decode),
-            props: { key, options },
-        });
-    }
-}
-export const union = UnionType.factory;
-export const or = UnionType.factory;
-export const intersection = IntersactionType.factory;
-export const and = IntersactionType.factory;
-export const discriminatedUnion = DiscriminatedUnionType.factory;