@nmtjs/type 0.10.2 → 0.10.4

package/dist/types/string.js

@@ -1,54 +1,55 @@
-import { cuid, cuid2, e164, email, emoji, ipv4, ipv6, jwt, maxLength, minLength, nanoid, regex, string, url, uuid } from "@zod/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: string().check(...checks),
+			encodedZodType: zod.string().check(...checks),
 			params: { checks }
 		});
 	}
 	max(value) {
-		return StringType.factory(...this.params.checks, maxLength(value));
+		return StringType.factory(...this.params.checks, zod.maxLength(value));
 	}
 	min(value) {
-		return StringType.factory(...this.params.checks, minLength(value));
+		return StringType.factory(...this.params.checks, zod.minLength(value));
 	}
 	pattern(pattern) {
-		return StringType.factory(...this.params.checks, regex(typeof pattern === "string" ? new RegExp(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, email(options));
+		return StringType.factory(...this.params.checks, zod.email(options));
 	}
 	url(options) {
-		return StringType.factory(...this.params.checks, url(options));
+		return StringType.factory(...this.params.checks, zod.url(options));
 	}
 	ipv4(options) {
-		return StringType.factory(...this.params.checks, ipv4(options));
+		return StringType.factory(...this.params.checks, zod.ipv4(options));
 	}
 	ipv6(options) {
-		return StringType.factory(...this.params.checks, ipv6(options));
+		return StringType.factory(...this.params.checks, zod.ipv6(options));
 	}
 	uuid(options) {
-		return StringType.factory(...this.params.checks, uuid(options));
+		return StringType.factory(...this.params.checks, zod.uuid(options));
 	}
 	emoji(options) {
-		return StringType.factory(...this.params.checks, emoji(options));
+		return StringType.factory(...this.params.checks, zod.emoji(options));
 	}
 	nanoid(options) {
-		return StringType.factory(...this.params.checks, nanoid(options));
+		return StringType.factory(...this.params.checks, zod.nanoid(options));
 	}
 	cuid(options) {
-		return StringType.factory(...this.params.checks, cuid(options));
+		return StringType.factory(...this.params.checks, zod.cuid(options));
 	}
 	cuid2(options) {
-		return StringType.factory(...this.params.checks, cuid2(options));
+		return StringType.factory(...this.params.checks, zod.cuid2(options));
 	}
 	e164(options) {
-		return StringType.factory(...this.params.checks, e164(options));
+		return StringType.factory(...this.params.checks, zod.e164(options));
 	}
 	jwt(options) {
-		return StringType.factory(...this.params.checks, jwt(options));
+		return StringType.factory(...this.params.checks, zod.jwt(options));
 	}
 }
+export const string = StringType.factory;
 
 //# sourceMappingURL=string.js.map

package/dist/types/string.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAEE,MACA,OACA,MACA,OACA,OACA,MACA,MACA,KACA,WACA,WACA,QACA,OACA,QACA,KACA,YAEK,WAAW;AAElB,SAAS,gBAAgB,WAAW;AAIpC,OAAO,MAAM,mBAAmB,SAG9B;CACA,OAAO,QAAQ,GAAG,QAAiB;AACjC,SAAO,IAAI,WAAW;GACpB,gBAAgB,QAAQ,CAAC,MAAM,GAAG,OAAO;GACzC,QAAQ,EAAE,OAAQ;EACnB;CACF;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,UAAU,MAAM,CAAC;CACnE;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,UAAU,MAAM,CAAC;CACnE;CAED,QAAQC,SAA0B;AAChC,SAAO,WAAW,QAChB,GAAG,KAAK,OAAO,QACf,aAAa,YAAY,WAAW,IAAI,OAAO,WAAW,QAAQ,CACnE;CACF;CAED,MAAMC,SAAgC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,MAAM,QAAQ,CAAC;CACjE;CAED,IAAIC,SAA8B;AAChC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,QAAQ,CAAC;CAC/D;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,MAAMC,SAAgC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,MAAM,QAAQ,CAAC;CACjE;CAED,OAAOC,SAAiC;AACtC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,OAAO,QAAQ,CAAC;CAClE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,MAAMC,SAAgC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,MAAM,QAAQ,CAAC;CACjE;CAED,KAAKC,SAA+B;AAClC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,KAAK,QAAQ,CAAC;CAChE;CAED,IAAIC,SAA8B;AAChC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,QAAQ,CAAC;CAC/D;AACF","names":["value: number","pattern: string | RegExp","options?: core.$ZodEmailParams","options?: core.$ZodURLParams","options?: core.$ZodIPv4Params","options?: core.$ZodIPv6Params","options?: core.$ZodUUIDParams","options?: core.$ZodEmojiParams","options?: core.$ZodNanoIDParams","options?: core.$ZodCUIDParams","options?: core.$ZodCUID2Params","options?: core.$ZodE164Params","options?: core.$ZodJWTParams"],"sources":["../../src/types/string.ts"],"sourcesContent":["import {\n  type core,\n  cuid,\n  cuid2,\n  e164,\n  email,\n  emoji,\n  ipv4,\n  ipv6,\n  jwt,\n  maxLength,\n  minLength,\n  nanoid,\n  regex,\n  string,\n  url,\n  uuid,\n  type ZodMiniString,\n} from '@zod/mini'\n\nimport { BaseType } from './base.ts'\n\ntype Check = core.CheckFn<string> | core.$ZodCheck<string>\n\nexport class StringType extends BaseType<\n  ZodMiniString<string>,\n  ZodMiniString<string>\n> {\n  static factory(...checks: Check[]) {\n    return new StringType({\n      encodedZodType: string().check(...checks),\n      params: { checks },\n    })\n  }\n\n  max(value: number) {\n    return StringType.factory(...this.params.checks, maxLength(value))\n  }\n\n  min(value: number) {\n    return StringType.factory(...this.params.checks, minLength(value))\n  }\n\n  pattern(pattern: string | RegExp) {\n    return StringType.factory(\n      ...this.params.checks,\n      regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),\n    )\n  }\n\n  email(options?: core.$ZodEmailParams) {\n    return StringType.factory(...this.params.checks, email(options))\n  }\n\n  url(options?: core.$ZodURLParams) {\n    return StringType.factory(...this.params.checks, url(options))\n  }\n\n  ipv4(options?: core.$ZodIPv4Params) {\n    return StringType.factory(...this.params.checks, ipv4(options))\n  }\n\n  ipv6(options?: core.$ZodIPv6Params) {\n    return StringType.factory(...this.params.checks, ipv6(options))\n  }\n\n  uuid(options?: core.$ZodUUIDParams) {\n    return StringType.factory(...this.params.checks, uuid(options))\n  }\n\n  emoji(options?: core.$ZodEmojiParams) {\n    return StringType.factory(...this.params.checks, emoji(options))\n  }\n\n  nanoid(options?: core.$ZodNanoIDParams) {\n    return StringType.factory(...this.params.checks, nanoid(options))\n  }\n\n  cuid(options?: core.$ZodCUIDParams) {\n    return StringType.factory(...this.params.checks, cuid(options))\n  }\n\n  cuid2(options?: core.$ZodCUID2Params) {\n    return StringType.factory(...this.params.checks, cuid2(options))\n  }\n\n  e164(options?: core.$ZodE164Params) {\n    return StringType.factory(...this.params.checks, e164(options))\n  }\n\n  jwt(options?: core.$ZodJWTParams) {\n    return StringType.factory(...this.params.checks, jwt(options))\n  }\n}\n"],"version":3,"file":"string.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAElC,SAAS,gBAAgB,WAAW;AAIpC,OAAO,MAAM,mBAAmB,SAG9B;CACA,OAAO,QAAQ,GAAG,QAAiB;AACjC,SAAO,IAAI,WAAW;GACpB,gBAAgB,IAAI,QAAQ,CAAC,MAAM,GAAG,OAAO;GAC7C,QAAQ,EAAE,OAAQ;EACnB;CACF;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,UAAU,MAAM,CAAC;CACvE;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,UAAU,MAAM,CAAC;CACvE;CAED,QAAQC,SAA0B;AAChC,SAAO,WAAW,QAChB,GAAG,KAAK,OAAO,QACf,IAAI,aAAa,YAAY,WAAW,IAAI,OAAO,WAAW,QAAQ,CACvE;CACF;CAED,MAAMC,SAAoC;AACxC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,MAAM,QAAQ,CAAC;CACrE;CAED,IAAIC,SAAkC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,IAAI,QAAQ,CAAC;CACnE;CAED,KAAKC,SAAmC;AACtC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,KAAK,QAAQ,CAAC;CACpE;CAED,KAAKC,SAAmC;AACtC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,KAAK,QAAQ,CAAC;CACpE;CAED,KAAKC,SAAmC;AACtC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,KAAK,QAAQ,CAAC;CACpE;CAED,MAAMC,SAAoC;AACxC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,MAAM,QAAQ,CAAC;CACrE;CAED,OAAOC,SAAqC;AAC1C,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,OAAO,QAAQ,CAAC;CACtE;CAED,KAAKC,SAAmC;AACtC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,KAAK,QAAQ,CAAC;CACpE;CAED,MAAMC,SAAoC;AACxC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,MAAM,QAAQ,CAAC;CACrE;CAED,KAAKC,SAAmC;AACtC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,KAAK,QAAQ,CAAC;CACpE;CAED,IAAIC,SAAkC;AACpC,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,IAAI,QAAQ,CAAC;CACnE;AACF;AAED,OAAO,MAAM,SAAS,WAAW","names":["value: number","pattern: string | RegExp","options?: zod.core.$ZodEmailParams","options?: zod.core.$ZodURLParams","options?: zod.core.$ZodIPv4Params","options?: zod.core.$ZodIPv6Params","options?: zod.core.$ZodUUIDParams","options?: zod.core.$ZodEmojiParams","options?: zod.core.$ZodNanoIDParams","options?: zod.core.$ZodCUIDParams","options?: zod.core.$ZodCUID2Params","options?: zod.core.$ZodE164Params","options?: zod.core.$ZodJWTParams"],"sources":["../../src/types/string.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\n\nimport { BaseType } from './base.ts'\n\ntype Check = zod.core.CheckFn<string> | zod.core.$ZodCheck<string>\n\nexport class StringType extends BaseType<\n  zod.ZodMiniString<string>,\n  zod.ZodMiniString<string>\n> {\n  static factory(...checks: Check[]) {\n    return new StringType({\n      encodedZodType: zod.string().check(...checks),\n      params: { checks },\n    })\n  }\n\n  max(value: number) {\n    return StringType.factory(...this.params.checks, zod.maxLength(value))\n  }\n\n  min(value: number) {\n    return StringType.factory(...this.params.checks, zod.minLength(value))\n  }\n\n  pattern(pattern: string | RegExp) {\n    return StringType.factory(\n      ...this.params.checks,\n      zod.regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),\n    )\n  }\n\n  email(options?: zod.core.$ZodEmailParams) {\n    return StringType.factory(...this.params.checks, zod.email(options))\n  }\n\n  url(options?: zod.core.$ZodURLParams) {\n    return StringType.factory(...this.params.checks, zod.url(options))\n  }\n\n  ipv4(options?: zod.core.$ZodIPv4Params) {\n    return StringType.factory(...this.params.checks, zod.ipv4(options))\n  }\n\n  ipv6(options?: zod.core.$ZodIPv6Params) {\n    return StringType.factory(...this.params.checks, zod.ipv6(options))\n  }\n\n  uuid(options?: zod.core.$ZodUUIDParams) {\n    return StringType.factory(...this.params.checks, zod.uuid(options))\n  }\n\n  emoji(options?: zod.core.$ZodEmojiParams) {\n    return StringType.factory(...this.params.checks, zod.emoji(options))\n  }\n\n  nanoid(options?: zod.core.$ZodNanoIDParams) {\n    return StringType.factory(...this.params.checks, zod.nanoid(options))\n  }\n\n  cuid(options?: zod.core.$ZodCUIDParams) {\n    return StringType.factory(...this.params.checks, zod.cuid(options))\n  }\n\n  cuid2(options?: zod.core.$ZodCUID2Params) {\n    return StringType.factory(...this.params.checks, zod.cuid2(options))\n  }\n\n  e164(options?: zod.core.$ZodE164Params) {\n    return StringType.factory(...this.params.checks, zod.e164(options))\n  }\n\n  jwt(options?: zod.core.$ZodJWTParams) {\n    return StringType.factory(...this.params.checks, zod.jwt(options))\n  }\n}\n\nexport const string = StringType.factory\n"],"version":3,"file":"string.js"}

package/dist/types/temporal.js

@@ -1,5 +1,5 @@
-import { iso, regex, string } from "@zod/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({
@@ -89,5 +89,12 @@ export class PlainMonthDayType extends TransformType {
 		});
 	}
 }
+export const plainDate = PlainDateType.factory;
+export const plainDatetime = PlainDateTimeType.factory;
+export const plainTime = PlainTimeType.factory;
+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/temporal.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,KAAK,OAAO,cAAkC,WAAW;AAClE,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,YAAY,qBAAqB,aAAa;AAYvD,MAAM,4BAA4B,CAChCA,MACA,SAAS,CAACC,UAAkB,SAAS,MAAM,KAAK,MAAM,KACnD;CACH,MAAM,SAAS,CAACC,UACd,MAAM,SAAS;EACb,cAAc;EACd,cAAc;EACd,cAAc;CACf,EAAC;AAEJ,QAAO;EACL;EACA;CACD;AACF;AAID,OAAO,MAAM,sBAAsB,cAGjC;CACA,OAAO,cAAc,0BAA0B,YAAY;CAE3D,OAAO,UAAU;AACf,SAAO,WAAW,QAAyC;GACzD,QAAQ,cAAc,YAAY;GAClC,QAAQ,cAAc,YAAY;GAClC,MAAM,IAAI,MAAM;GAChB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,gBAAgB;CAE/D,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,IAAI,SAAS,EAAE,OAAO,KAAM,EAAC;GACnC,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,iBAAiB,CAAC,UAC/D,SAAS,QAAQ,KAAK,MAAM,CAAC,mBAAmB,MAAM,CACvD;CAED,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,IAAI,SAAS,EAAE,OAAO,KAAM,EAAC;GACnC,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,sBAAsB,cAGjC;CACA,OAAO,cAAc,0BAA0B,YAAY;CAE3D,OAAO,UAAU;AACf,SAAO,WAAW,QAAyC;GACzD,QAAQ,cAAc,YAAY;GAClC,QAAQ,cAAc,YAAY;GAClC,MAAM,IAAI,MAAM;GAChB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,qBAAqB,cAGhC;CACA,OAAO,cAAc,0BAA0B,WAAW;CAE1D,OAAO,UAAU;AACf,SAAO,WAAW,QAAwC;GACxD,QAAQ,aAAa,YAAY;GACjC,QAAQ,aAAa,YAAY;GACjC,MAAM,IAAI,UAAU;GACpB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,2BAA2B,cAGtC;CACA,OAAO,cAAc,0BAA0B,iBAAiB;CAEhE,OAAO,UAAU;AACf,SAAO,WAAW,QAA8C;GAC9D,QAAQ,mBAAmB,YAAY;GACvC,QAAQ,mBAAmB,YAAY;GACvC,MAAM,QAAQ,CAAC,MAAM,MAAM,gBAAgB,CAAC;GAC5C,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,gBAAgB;CAE/D,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,QAAQ,CAAC,MAAM,MAAM,gBAAgB,CAAC;GAC5C,OAAO;EACR,EAAC;CACH;AACF","names":["type: T","value: string","value: ReturnType<(typeof Temporal)[T]['from']>"],"sources":["../../src/types/temporal.ts"],"sourcesContent":["import { iso, regex, string, type ZodMiniString } from '@zod/mini'\nimport { Temporal } from 'temporal-polyfill'\nimport { CustomType, TransformType } from './custom.ts'\n\ntype Types = Exclude<\n  keyof typeof Temporal,\n  'Now' | 'Instant' | 'Calendar' | 'TimeZone'\n>\n\ntype TemporalTransformer<T extends Types> = {\n  decode: (value: string) => ReturnType<(typeof Temporal)[T]['from']>\n  encode: (value: ReturnType<(typeof Temporal)[T]['from']>) => string\n}\n\nconst createTemporalTransformer = <T extends Types>(\n  type: T,\n  decode = (value: string) => Temporal[type].from(value),\n) => {\n  const encode = (value: ReturnType<(typeof Temporal)[T]['from']>) =>\n    value.toString({\n      calendarName: 'never',\n      smallestUnit: 'microsecond',\n      timeZoneName: 'never',\n    })\n\n  return {\n    decode,\n    encode,\n  } as TemporalTransformer<T>\n}\n\ntype EncodedType = ZodMiniString<string>\n\nexport class PlainDateType extends TransformType<\n  Temporal.PlainDate,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainDate')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainDate, EncodedType>({\n      decode: PlainDateType.transformer.decode,\n      encode: PlainDateType.transformer.encode,\n      type: iso.date(),\n      error: 'Invalid date format',\n    })\n  }\n}\n\nexport class PlainDateTimeType extends TransformType<\n  Temporal.PlainDateTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainDateTime')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainDateTime, EncodedType>({\n      decode: PlainDateTimeType.transformer.decode,\n      encode: PlainDateTimeType.transformer.encode,\n      type: iso.datetime({ local: true }),\n      error: 'Invalid datetime format',\n    })\n  }\n}\n\nexport class ZonedDateTimeType extends TransformType<\n  Temporal.ZonedDateTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('ZonedDateTime', (value) =>\n    Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),\n  )\n\n  static factory() {\n    return CustomType.factory<Temporal.ZonedDateTime, EncodedType>({\n      decode: ZonedDateTimeType.transformer.decode,\n      encode: ZonedDateTimeType.transformer.encode,\n      type: iso.datetime({ local: true }),\n      error: 'Invalid datetime format',\n    })\n  }\n}\n\nexport class PlainTimeType extends TransformType<\n  Temporal.PlainTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainTime')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainTime, EncodedType>({\n      decode: PlainTimeType.transformer.decode,\n      encode: PlainTimeType.transformer.encode,\n      type: iso.time(),\n      error: 'Invalid time format',\n    })\n  }\n}\n\nexport class DurationType extends TransformType<\n  Temporal.Duration,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('Duration')\n\n  static factory() {\n    return CustomType.factory<Temporal.Duration, EncodedType>({\n      decode: DurationType.transformer.decode,\n      encode: DurationType.transformer.encode,\n      type: iso.duration(),\n      error: 'Invalid duration format',\n    })\n  }\n}\n\nexport class PlainYearMonthType extends TransformType<\n  Temporal.PlainYearMonth,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainYearMonth')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainYearMonth, EncodedType>({\n      decode: PlainYearMonthType.transformer.decode,\n      encode: PlainYearMonthType.transformer.encode,\n      type: string().check(regex(/^\\d{4}-\\d{2}$/)),\n      error: 'Invalid year-month format',\n    })\n  }\n}\n\nexport class PlainMonthDayType extends TransformType<\n  Temporal.PlainMonthDay,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainMonthDay')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainMonthDay, EncodedType>({\n      decode: PlainMonthDayType.transformer.decode,\n      encode: PlainMonthDayType.transformer.encode,\n      type: string().check(regex(/^\\d{2}-\\d{2}$/)),\n      error: 'Invalid month-day format',\n    })\n  }\n}\n"],"version":3,"file":"temporal.js"}
+{"mappings":"AAAA,SAAS,gBAAgB,mBAAmB;AAC5C,SAAS,KAAK,OAAO,cAAkC,aAAa;AACpE,SAAS,YAAY,qBAAqB,aAAa;AAYvD,MAAM,4BAA4B,CAChCA,MACA,SAAS,CAACC,UAAkB,SAAS,MAAM,KAAK,MAAM,KACnD;CACH,MAAM,SAAS,CAACC,UACd,MAAM,SAAS;EACb,cAAc;EACd,cAAc;EACd,cAAc;CACf,EAAC;AAEJ,QAAO;EACL;EACA;CACD;AACF;AAID,OAAO,MAAM,sBAAsB,cAGjC;CACA,OAAO,cAAc,0BAA0B,YAAY;CAE3D,OAAO,UAAU;AACf,SAAO,WAAW,QAAyC;GACzD,QAAQ,cAAc,YAAY;GAClC,QAAQ,cAAc,YAAY;GAClC,MAAM,IAAI,MAAM;GAChB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,gBAAgB;CAE/D,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,IAAI,SAAS,EAAE,OAAO,KAAM,EAAC;GACnC,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,iBAAiB,CAAC,UAC/D,SAAS,QAAQ,KAAK,MAAM,CAAC,mBAAmB,MAAM,CACvD;CAED,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,IAAI,SAAS,EAAE,OAAO,KAAM,EAAC;GACnC,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,sBAAsB,cAGjC;CACA,OAAO,cAAc,0BAA0B,YAAY;CAE3D,OAAO,UAAU;AACf,SAAO,WAAW,QAAyC;GACzD,QAAQ,cAAc,YAAY;GAClC,QAAQ,cAAc,YAAY;GAClC,MAAM,IAAI,MAAM;GAChB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,qBAAqB,cAGhC;CACA,OAAO,cAAc,0BAA0B,WAAW;CAE1D,OAAO,UAAU;AACf,SAAO,WAAW,QAAwC;GACxD,QAAQ,aAAa,YAAY;GACjC,QAAQ,aAAa,YAAY;GACjC,MAAM,IAAI,UAAU;GACpB,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,2BAA2B,cAGtC;CACA,OAAO,cAAc,0BAA0B,iBAAiB;CAEhE,OAAO,UAAU;AACf,SAAO,WAAW,QAA8C;GAC9D,QAAQ,mBAAmB,YAAY;GACvC,QAAQ,mBAAmB,YAAY;GACvC,MAAM,QAAQ,CAAC,MAAM,MAAM,gBAAgB,CAAC;GAC5C,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,0BAA0B,cAGrC;CACA,OAAO,cAAc,0BAA0B,gBAAgB;CAE/D,OAAO,UAAU;AACf,SAAO,WAAW,QAA6C;GAC7D,QAAQ,kBAAkB,YAAY;GACtC,QAAQ,kBAAkB,YAAY;GACtC,MAAM,QAAQ,CAAC,MAAM,MAAM,gBAAgB,CAAC;GAC5C,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,YAAY,cAAc;AACvC,OAAO,MAAM,gBAAgB,kBAAkB;AAC/C,OAAO,MAAM,YAAY,cAAc;AACvC,OAAO,MAAM,gBAAgB,kBAAkB;AAC/C,OAAO,MAAM,WAAW,aAAa;AACrC,OAAO,MAAM,iBAAiB,mBAAmB;AACjD,OAAO,MAAM,gBAAgB,kBAAkB","names":["type: T","value: string","value: ReturnType<(typeof Temporal)[T]['from']>"],"sources":["../../src/types/temporal.ts"],"sourcesContent":["import { Temporal } from 'temporal-polyfill'\nimport { iso, regex, string, type ZodMiniString } from 'zod/v4-mini'\nimport { CustomType, TransformType } from './custom.ts'\n\ntype Types = Exclude<\n  keyof typeof Temporal,\n  'Now' | 'Instant' | 'Calendar' | 'TimeZone'\n>\n\ntype TemporalTransformer<T extends Types> = {\n  decode: (value: string) => ReturnType<(typeof Temporal)[T]['from']>\n  encode: (value: ReturnType<(typeof Temporal)[T]['from']>) => string\n}\n\nconst createTemporalTransformer = <T extends Types>(\n  type: T,\n  decode = (value: string) => Temporal[type].from(value),\n) => {\n  const encode = (value: ReturnType<(typeof Temporal)[T]['from']>) =>\n    value.toString({\n      calendarName: 'never',\n      smallestUnit: 'microsecond',\n      timeZoneName: 'never',\n    })\n\n  return {\n    decode,\n    encode,\n  } as TemporalTransformer<T>\n}\n\ntype EncodedType = ZodMiniString<string>\n\nexport class PlainDateType extends TransformType<\n  Temporal.PlainDate,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainDate')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainDate, EncodedType>({\n      decode: PlainDateType.transformer.decode,\n      encode: PlainDateType.transformer.encode,\n      type: iso.date(),\n      error: 'Invalid date format',\n    })\n  }\n}\n\nexport class PlainDateTimeType extends TransformType<\n  Temporal.PlainDateTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainDateTime')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainDateTime, EncodedType>({\n      decode: PlainDateTimeType.transformer.decode,\n      encode: PlainDateTimeType.transformer.encode,\n      type: iso.datetime({ local: true }),\n      error: 'Invalid datetime format',\n    })\n  }\n}\n\nexport class ZonedDateTimeType extends TransformType<\n  Temporal.ZonedDateTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('ZonedDateTime', (value) =>\n    Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),\n  )\n\n  static factory() {\n    return CustomType.factory<Temporal.ZonedDateTime, EncodedType>({\n      decode: ZonedDateTimeType.transformer.decode,\n      encode: ZonedDateTimeType.transformer.encode,\n      type: iso.datetime({ local: true }),\n      error: 'Invalid datetime format',\n    })\n  }\n}\n\nexport class PlainTimeType extends TransformType<\n  Temporal.PlainTime,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainTime')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainTime, EncodedType>({\n      decode: PlainTimeType.transformer.decode,\n      encode: PlainTimeType.transformer.encode,\n      type: iso.time(),\n      error: 'Invalid time format',\n    })\n  }\n}\n\nexport class DurationType extends TransformType<\n  Temporal.Duration,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('Duration')\n\n  static factory() {\n    return CustomType.factory<Temporal.Duration, EncodedType>({\n      decode: DurationType.transformer.decode,\n      encode: DurationType.transformer.encode,\n      type: iso.duration(),\n      error: 'Invalid duration format',\n    })\n  }\n}\n\nexport class PlainYearMonthType extends TransformType<\n  Temporal.PlainYearMonth,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainYearMonth')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainYearMonth, EncodedType>({\n      decode: PlainYearMonthType.transformer.decode,\n      encode: PlainYearMonthType.transformer.encode,\n      type: string().check(regex(/^\\d{4}-\\d{2}$/)),\n      error: 'Invalid year-month format',\n    })\n  }\n}\n\nexport class PlainMonthDayType extends TransformType<\n  Temporal.PlainMonthDay,\n  EncodedType\n> {\n  static transformer = createTemporalTransformer('PlainMonthDay')\n\n  static factory() {\n    return CustomType.factory<Temporal.PlainMonthDay, EncodedType>({\n      decode: PlainMonthDayType.transformer.decode,\n      encode: PlainMonthDayType.transformer.encode,\n      type: string().check(regex(/^\\d{2}-\\d{2}$/)),\n      error: 'Invalid month-day format',\n    })\n  }\n}\n\nexport const plainDate = PlainDateType.factory\nexport const plainDatetime = PlainDateTimeType.factory\nexport const plainTime = PlainTimeType.factory\nexport const zonedDatetime = ZonedDateTimeType.factory\nexport const duration = DurationType.factory\nexport const plainYearMonth = PlainYearMonthType.factory\nexport const plainMonthDay = PlainMonthDayType.factory\n"],"version":3,"file":"temporal.js"}

package/dist/types/tuple.js

@@ -1,12 +1,12 @@
-import { tuple } from "@zod/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: tuple(encoded, rest?.encodedZodType),
-			decodedZodType: tuple(decoded, rest?.decodedZodType),
+			encodedZodType: zod.tuple(encoded, rest?.encodedZodType),
+			decodedZodType: zod.tuple(decoded, rest?.decodedZodType),
 			props: {
 				elements,
 				rest
@@ -14,5 +14,6 @@ export class TupleType extends BaseType {
 		});
 	}
 }
+export const tuple = TupleType.factory;
 
 //# sourceMappingURL=tuple.js.map

package/dist/types/tuple.js.map

@@ -1 +1 @@
-{"mappings":"AACA,SAAS,aAAgC,WAAW;AACpD,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,kBAMH,SAQR;CACA,OAAO,QAGLA,UAAaC,OAAU,MAAW;EAClC,MAAM,UAAU,SAAS,IAAI,CAAC,OAAO,GAAG,eAAe;EACvD,MAAM,UAAU,SAAS,IAAI,CAAC,OAAO,GAAG,eAAe;AACvD,SAAO,IAAI,UAAgB;GAEzB,gBAAgB,MAAM,SAAS,MAAM,eAAe;GAEpD,gBAAgB,MAAM,SAAS,MAAM,eAAe;GACpD,OAAO;IAAE;IAAU;GAAM;EAC1B;CACF;AACF","names":["elements: T","rest: R"],"sources":["../../src/types/tuple.ts"],"sourcesContent":["import type { ArrayMap } from '@nmtjs/common'\nimport { tuple, type ZodMiniTuple } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class TupleType<\n  T extends readonly [BaseType, ...BaseType[]] = readonly [\n    BaseType,\n    ...BaseType[],\n  ],\n  R extends BaseType | null = BaseType | null,\n> extends BaseType<\n  R extends BaseType\n    ? ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, R['encodedZodType']>\n    : ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, null>,\n  R extends BaseType\n    ? ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, R['decodedZodType']>\n    : ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, null>,\n  { elements: T; rest?: R }\n> {\n  static factory<\n    T extends readonly [BaseType, ...BaseType[]],\n    R extends BaseType | null = null,\n  >(elements: T, rest: R = null as R) {\n    const encoded = elements.map((el) => el.encodedZodType)\n    const decoded = elements.map((el) => el.decodedZodType)\n    return new TupleType<T, R>({\n      // @ts-expect-error\n      encodedZodType: tuple(encoded, rest?.encodedZodType),\n      // @ts-expect-error\n      decodedZodType: tuple(decoded, rest?.decodedZodType),\n      props: { elements, rest },\n    })\n  }\n}\n"],"version":3,"file":"tuple.js"}
+{"mappings":"AACA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,kBAMH,SAQR;CACA,OAAO,QAGLA,UAAaC,OAAU,MAAW;EAClC,MAAM,UAAU,SAAS,IAAI,CAAC,OAAO,GAAG,eAAe;EACvD,MAAM,UAAU,SAAS,IAAI,CAAC,OAAO,GAAG,eAAe;AACvD,SAAO,IAAI,UAAgB;GAEzB,gBAAgB,IAAI,MAAM,SAAS,MAAM,eAAe;GAExD,gBAAgB,IAAI,MAAM,SAAS,MAAM,eAAe;GACxD,OAAO;IAAE;IAAU;GAAM;EAC1B;CACF;AACF;AAED,OAAO,MAAM,QAAQ,UAAU","names":["elements: T","rest: R"],"sources":["../../src/types/tuple.ts"],"sourcesContent":["import type { ArrayMap } from '@nmtjs/common'\nimport * as zod from 'zod/v4-mini'\nimport { BaseType } from './base.ts'\n\nexport class TupleType<\n  T extends readonly [BaseType, ...BaseType[]] = readonly [\n    BaseType,\n    ...BaseType[],\n  ],\n  R extends BaseType | null = BaseType | null,\n> extends BaseType<\n  R extends BaseType\n    ? zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, R['encodedZodType']>\n    : zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, null>,\n  R extends BaseType\n    ? zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, R['decodedZodType']>\n    : zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, null>,\n  { elements: T; rest?: R }\n> {\n  static factory<\n    T extends readonly [BaseType, ...BaseType[]],\n    R extends BaseType | null = null,\n  >(elements: T, rest: R = null as R) {\n    const encoded = elements.map((el) => el.encodedZodType)\n    const decoded = elements.map((el) => el.decodedZodType)\n    return new TupleType<T, R>({\n      // @ts-expect-error\n      encodedZodType: zod.tuple(encoded, rest?.encodedZodType),\n      // @ts-expect-error\n      decodedZodType: zod.tuple(decoded, rest?.decodedZodType),\n      props: { elements, rest },\n    })\n  }\n}\n\nexport const tuple = TupleType.factory\n"],"version":3,"file":"tuple.js"}

package/dist/types/type.js

@@ -0,0 +1,15 @@
+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";
+
+//# sourceMappingURL=type.js.map

package/dist/types/type.js.map

@@ -0,0 +1 @@
+{"mappings":"AAEA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc","names":[],"sources":["../../src/types/type.ts"],"sourcesContent":["import type { BaseTypeAny } from './base.ts'\n\nexport * from './any.ts'\nexport * from './array.ts'\nexport * from './boolean.ts'\nexport * from './custom.ts'\nexport * from './date.ts'\nexport * from './enum.ts'\nexport * from './literal.ts'\nexport * from './never.ts'\nexport * from './number.ts'\nexport * from './object.ts'\nexport * from './string.ts'\nexport * from './tuple.ts'\nexport * from './union.ts'\n\nexport namespace infer {\n  export namespace decoded {\n    export type input<T extends BaseTypeAny> =\n      T['decodedZodType']['_zod']['input']\n    export type output<T extends BaseTypeAny> =\n      T['decodedZodType']['_zod']['output']\n  }\n\n  export namespace encoded {\n    export type input<T extends BaseTypeAny> =\n      T['encodedZodType']['_zod']['input']\n    export type output<T extends BaseTypeAny> =\n      T['encodedZodType']['_zod']['output']\n  }\n}\n"],"version":3,"file":"type.js"}

package/dist/types/union.js

@@ -1,12 +1,12 @@
-import { discriminatedUnion, intersection, union } from "@zod/mini";
+import * as zod from "zod/v4-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);
 		return new UnionType({
-			encodedZodType: union(encoded),
-			decodedZodType: union(decoded),
+			encodedZodType: zod.union(encoded),
+			decodedZodType: zod.union(decoded),
 			props: { options }
 		});
 	}
@@ -15,8 +15,8 @@ export class IntersactionType extends BaseType {
 	static factory(...options) {
 		const [first, second] = options;
 		return new IntersactionType({
-			encodedZodType: intersection(first.encodedZodType, second.encodedZodType),
-			decodedZodType: intersection(first.decodedZodType, second.decodedZodType),
+			encodedZodType: zod.intersection(first.encodedZodType, second.encodedZodType),
+			decodedZodType: zod.intersection(first.decodedZodType, second.decodedZodType),
 			props: { options }
 		});
 	}
@@ -26,8 +26,8 @@ export class DiscriminatedUnionType extends BaseType {
 		const encoded = options.map((t) => t.encodedZodType);
 		const decoded = options.map((t) => t.decodedZodType);
 		return new DiscriminatedUnionType({
-			encodedZodType: discriminatedUnion(encoded),
-			decodedZodType: discriminatedUnion(decoded),
+			encodedZodType: zod.discriminatedUnion(key, encoded),
+			decodedZodType: zod.discriminatedUnion(key, decoded),
 			props: {
 				key,
 				options
@@ -35,5 +35,10 @@ export class DiscriminatedUnionType extends BaseType {
 		});
 	}
 }
+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;
 
 //# sourceMappingURL=union.js.map

package/dist/types/union.js.map

@@ -1 +1 @@
-{"mappings":"AACA,SAEE,oBACA,cACA,aAIK,WAAW;AAClB,SAAS,gBAAkC,WAAW;AAItD,OAAO,MAAM,kBAKH,SAIR;CACA,OAAO,QAKL,GAAG,SAAY;EACf,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;EAIpD,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;AAIpD,SAAO,IAAI,UAAa;GACtB,gBAAgB,MAAM,QAAQ;GAC9B,gBAAgB,MAAM,QAAQ;GAC9B,OAAO,EAAE,QAAS;EACnB;CACF;AACF;AAED,OAAO,MAAM,yBAEH,SAIR;CACA,OAAO,QAEL,GAAG,SAAY;EACf,MAAM,CAAC,OAAO,OAAO,GAAG;AACxB,SAAO,IAAI,iBAAoB;GAC7B,gBAAgB,aAAa,MAAM,gBAAgB,OAAO,eAAe;GACzE,gBAAgB,aAAa,MAAM,gBAAgB,OAAO,eAAe;GACzE,OAAO,EAAE,QAAS;EACnB;CACF;AACF;AAYD,OAAO,MAAM,+BAIH,SAOR;CACA,OAAO,QAILA,KAAQ,GAAG,SAAY;EACvB,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;EAIpD,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;AAIpD,SAAO,IAAI,uBAA6B;GAEtC,gBAAgB,mBAAmB,QAAQ;GAE3C,gBAAgB,mBAAmB,QAAQ;GAC3C,OAAO;IAAE;IAAK;GAAS;EACxB;CACF;AACF","names":["key: K"],"sources":["../../src/types/union.ts"],"sourcesContent":["import type { ArrayMap } from '@nmtjs/common'\nimport {\n  type core,\n  discriminatedUnion,\n  intersection,\n  union,\n  type ZodMiniDiscriminatedUnion,\n  type ZodMiniIntersection,\n  type ZodMiniUnion,\n} from '@zod/mini'\nimport { BaseType, type BaseTypeAny } from './base.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { ObjectType, ObjectTypeProps } from './object.ts'\n\nexport class UnionType<\n  T extends readonly [BaseType, ...BaseType[]] = readonly [\n    BaseType,\n    ...BaseType[],\n  ],\n> extends BaseType<\n  ZodMiniUnion<ArrayMap<T, 'encodedZodType'>>,\n  ZodMiniUnion<ArrayMap<T, 'decodedZodType'>>,\n  { options: T }\n> {\n  static factory<\n    T extends readonly [BaseType, ...BaseType[]] = readonly [\n      BaseType,\n      ...BaseType[],\n    ],\n  >(...options: T) {\n    const encoded = options.map((t) => t.encodedZodType) as ArrayMap<\n      T,\n      'encodedZodType'\n    >\n    const decoded = options.map((t) => t.decodedZodType) as ArrayMap<\n      T,\n      'decodedZodType'\n    >\n    return new UnionType<T>({\n      encodedZodType: union(encoded),\n      decodedZodType: union(decoded),\n      props: { options },\n    })\n  }\n}\n\nexport class IntersactionType<\n  T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],\n> extends BaseType<\n  ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>,\n  ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>,\n  { options: T }\n> {\n  static factory<\n    T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],\n  >(...options: T) {\n    const [first, second] = options\n    return new IntersactionType<T>({\n      encodedZodType: intersection(first.encodedZodType, second.encodedZodType),\n      decodedZodType: intersection(first.decodedZodType, second.decodedZodType),\n      props: { options },\n    })\n  }\n}\n\nexport type DiscriminatedUnionProperties<K extends string = string> = {\n  [OK in K]: LiteralType<string>\n} & {\n  [OK in string]: any\n}\n\nexport type DiscriminatedUnionOptionType<K extends string> = ObjectType<\n  ObjectTypeProps & { [_ in K]: BaseTypeAny }\n>\n\nexport class DiscriminatedUnionType<\n  K extends string = string,\n  T extends\n    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n> extends BaseType<\n  ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodedZodType'>>,\n  ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodedZodType'>>,\n  {\n    key: K\n    options: T\n  }\n> {\n  static factory<\n    K extends string = string,\n    T extends\n      readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n  >(key: K, ...options: T) {\n    const encoded = options.map((t) => t.encodedZodType) as ArrayMap<\n      T,\n      'encodedZodType'\n    >\n    const decoded = options.map((t) => t.decodedZodType) as ArrayMap<\n      T,\n      'decodedZodType'\n    >\n    return new DiscriminatedUnionType<K, T>({\n      // @ts-expect-error\n      encodedZodType: discriminatedUnion(encoded),\n      // @ts-expect-error\n      decodedZodType: discriminatedUnion(decoded),\n      props: { key, options },\n    })\n  }\n}\n"],"version":3,"file":"union.js"}
+{"mappings":"AACA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAkC,WAAW;AAItD,OAAO,MAAM,kBAKH,SAIR;CACA,OAAO,QAKL,GAAG,SAAY;EACf,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;EAIpD,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;AAIpD,SAAO,IAAI,UAAa;GACtB,gBAAgB,IAAI,MAAM,QAAQ;GAClC,gBAAgB,IAAI,MAAM,QAAQ;GAClC,OAAO,EAAE,QAAS;EACnB;CACF;AACF;AAED,OAAO,MAAM,yBAEH,SAIR;CACA,OAAO,QAEL,GAAG,SAAY;EACf,MAAM,CAAC,OAAO,OAAO,GAAG;AACxB,SAAO,IAAI,iBAAoB;GAC7B,gBAAgB,IAAI,aAClB,MAAM,gBACN,OAAO,eACR;GACD,gBAAgB,IAAI,aAClB,MAAM,gBACN,OAAO,eACR;GACD,OAAO,EAAE,QAAS;EACnB;CACF;AACF;AAYD,OAAO,MAAM,+BAIH,SAOR;CACA,OAAO,QAILA,KAAQ,GAAG,SAAY;EACvB,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;EAIpD,MAAM,UAAU,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe;AAIpD,SAAO,IAAI,uBAA6B;GAEtC,gBAAgB,IAAI,mBAAmB,KAAK,QAAQ;GAEpD,gBAAgB,IAAI,mBAAmB,KAAK,QAAQ;GACpD,OAAO;IAAE;IAAK;GAAS;EACxB;CACF;AACF;AAED,OAAO,MAAM,QAAQ,UAAU;AAC/B,OAAO,MAAM,KAAK,UAAU;AAC5B,OAAO,MAAM,eAAe,iBAAiB;AAC7C,OAAO,MAAM,MAAM,iBAAiB;AACpC,OAAO,MAAM,qBAAqB,uBAAuB","names":["key: K"],"sources":["../../src/types/union.ts"],"sourcesContent":["import type { ArrayMap } from '@nmtjs/common'\nimport * as zod from 'zod/v4-mini'\nimport { BaseType, type BaseTypeAny } from './base.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { ObjectType, ObjectTypeProps } from './object.ts'\n\nexport class UnionType<\n  T extends readonly [BaseType, ...BaseType[]] = readonly [\n    BaseType,\n    ...BaseType[],\n  ],\n> extends BaseType<\n  zod.ZodMiniUnion<ArrayMap<T, 'encodedZodType'>>,\n  zod.ZodMiniUnion<ArrayMap<T, 'decodedZodType'>>,\n  { options: T }\n> {\n  static factory<\n    T extends readonly [BaseType, ...BaseType[]] = readonly [\n      BaseType,\n      ...BaseType[],\n    ],\n  >(...options: T) {\n    const encoded = options.map((t) => t.encodedZodType) as ArrayMap<\n      T,\n      'encodedZodType'\n    >\n    const decoded = options.map((t) => t.decodedZodType) as ArrayMap<\n      T,\n      'decodedZodType'\n    >\n    return new UnionType<T>({\n      encodedZodType: zod.union(encoded),\n      decodedZodType: zod.union(decoded),\n      props: { options },\n    })\n  }\n}\n\nexport class IntersactionType<\n  T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],\n> extends BaseType<\n  zod.ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>,\n  zod.ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>,\n  { options: T }\n> {\n  static factory<\n    T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],\n  >(...options: T) {\n    const [first, second] = options\n    return new IntersactionType<T>({\n      encodedZodType: zod.intersection(\n        first.encodedZodType,\n        second.encodedZodType,\n      ),\n      decodedZodType: zod.intersection(\n        first.decodedZodType,\n        second.decodedZodType,\n      ),\n      props: { options },\n    })\n  }\n}\n\nexport type DiscriminatedUnionProperties<K extends string = string> = {\n  [OK in K]: LiteralType<string>\n} & {\n  [OK in string]: any\n}\n\nexport type DiscriminatedUnionOptionType<K extends string> = ObjectType<\n  ObjectTypeProps & { [_ in K]: BaseTypeAny }\n>\n\nexport class DiscriminatedUnionType<\n  K extends string = string,\n  T extends\n    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n> extends BaseType<\n  zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodedZodType'>>,\n  zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodedZodType'>>,\n  {\n    key: K\n    options: T\n  }\n> {\n  static factory<\n    K extends string = string,\n    T extends\n      readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n  >(key: K, ...options: T) {\n    const encoded = options.map((t) => t.encodedZodType) as ArrayMap<\n      T,\n      'encodedZodType'\n    >\n    const decoded = options.map((t) => t.decodedZodType) as ArrayMap<\n      T,\n      'decodedZodType'\n    >\n    return new DiscriminatedUnionType<K, T>({\n      // @ts-expect-error\n      encodedZodType: zod.discriminatedUnion(key, encoded),\n      // @ts-expect-error\n      decodedZodType: zod.discriminatedUnion(key, decoded),\n      props: { key, options },\n    })\n  }\n}\n\nexport const union = UnionType.factory\nexport const or = UnionType.factory\nexport const intersection = IntersactionType.factory\nexport const and = IntersactionType.factory\nexport const discriminatedUnion = DiscriminatedUnionType.factory\n"],"version":3,"file":"union.js"}

package/package.json

@@ -11,15 +11,15 @@
       "types": "./src/temporal.ts"
     }
   },
-  "dependencies": {
-    "@zod/mini": "4.0.0-beta.20250503T014749",
-    "temporal-polyfill": "^0.3.0"
-  },
   "peerDependencies": {
-    "@nmtjs/common": "0.10.2"
+    "temporal-polyfill": "^0.3.0",
+    "zod": "^3.25.0",
+    "@nmtjs/common": "0.10.4"
   },
   "devDependencies": {
-    "@nmtjs/common": "0.10.2"
+    "temporal-polyfill": "^0.3.0",
+    "zod": "^3.25.0",
+    "@nmtjs/common": "0.10.4"
   },
   "files": [
     "src",
@@ -27,7 +27,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.10.2",
+  "version": "0.10.4",
   "scripts": {
     "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/index.ts

@@ -1,101 +1,8 @@
-import * as zod from '@zod/mini'
-import { AnyType } from './types/any.ts'
-import { ArrayType } from './types/array.ts'
-import type { BaseTypeAny } from './types/base.ts'
-import { BooleanType } from './types/boolean.ts'
-import { CustomType } from './types/custom.ts'
-import { DateType } from './types/date.ts'
-import { EnumType } from './types/enum.ts'
-import { LiteralType } from './types/literal.ts'
-import { NeverType } from './types/never.ts'
-import { BigIntType, IntegerType, NumberType } from './types/number.ts'
-import {
-  extend,
-  keyof,
-  merge,
-  ObjectType,
-  omit,
-  partial,
-  pick,
-  RecordType,
-} from './types/object.ts'
-import { StringType } from './types/string.ts'
-import { TupleType } from './types/tuple.ts'
-import {
-  DiscriminatedUnionType,
-  IntersactionType,
-  UnionType,
-} from './types/union.ts'
+import * as zod from 'zod/v4-mini'
+import * as type from './types/type.ts'
 
 zod.config(zod.core.locales.en())
 
-export { NeemataTypeError } from './types/base.ts'
-export { BaseType, type BaseTypeAny } from './types/base.ts'
-export {
-  AnyType,
-  ArrayType,
-  BooleanType,
-  CustomType,
-  DateType,
-  EnumType,
-  LiteralType,
-  IntegerType,
-  NumberType,
-  ObjectType,
-  StringType,
-  IntersactionType,
-  UnionType,
-  TupleType,
-  NeverType,
-  DiscriminatedUnionType,
-  RecordType,
-}
-
-export namespace type {
-  export namespace infer {
-    export namespace decoded {
-      export type input<T extends BaseTypeAny> =
-        T['decodedZodType']['_zod']['input']
-      export type output<T extends BaseTypeAny> =
-        T['decodedZodType']['_zod']['output']
-    }
-
-    export namespace encoded {
-      export type input<T extends BaseTypeAny> =
-        T['encodedZodType']['_zod']['input']
-      export type output<T extends BaseTypeAny> =
-        T['encodedZodType']['_zod']['output']
-    }
-  }
-}
-
-export const type = {
-  never: NeverType.factory,
-  boolean: BooleanType.factory,
-  string: StringType.factory,
-  number: NumberType.factory,
-  integer: IntegerType.factory,
-  bigint: BigIntType.factory,
-  literal: LiteralType.factory,
-  enum: EnumType.factory,
-  tuple: TupleType.factory,
-  date: DateType.factory,
-  array: ArrayType.factory,
-  record: RecordType.factory,
-  any: AnyType.factory,
-  or: UnionType.factory,
-  and: IntersactionType.factory,
-  union: UnionType.factory,
-  intersaction: IntersactionType.factory,
-  discriminatedUnion: DiscriminatedUnionType.factory,
-  custom: CustomType.factory,
-  object: ObjectType.factory,
-  keyof,
-  partial,
-  merge,
-  omit,
-  extend,
-  pick,
-}
-export { type as t, zod }
+export * from './types/base.ts'
+export { type, type as t }
 export default type

package/src/temporal.ts

@@ -1,27 +1 @@
-import {
-  DurationType,
-  PlainDateTimeType,
-  PlainDateType,
-  PlainMonthDayType,
-  PlainTimeType,
-  PlainYearMonthType,
-  ZonedDateTimeType,
-} from './types/temporal.ts'
-
-export const plainDate = PlainDateType.factory
-export const plainDatetime = PlainDateTimeType.factory
-export const plainTime = PlainTimeType.factory
-export const zonedDatetime = ZonedDateTimeType.factory
-export const duration = DurationType.factory
-export const plainYearMonth = PlainYearMonthType.factory
-export const plainMonthDay = PlainMonthDayType.factory
-
-export type {
-  DurationType,
-  PlainDateTimeType,
-  PlainDateType,
-  PlainMonthDayType,
-  PlainTimeType,
-  PlainYearMonthType,
-  ZonedDateTimeType,
-}
+export * from './types/temporal.ts'

package/src/types/any.ts

@@ -1,10 +1,12 @@
-import { any, type ZodMiniAny } from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType } from './base.ts'
 
-export class AnyType extends BaseType<ZodMiniAny> {
+export class AnyType extends BaseType<zod.ZodMiniAny> {
   static factory() {
     return new AnyType({
-      encodedZodType: any(),
+      encodedZodType: zod.any(),
     })
   }
 }
+
+export const any = AnyType.factory

package/src/types/array.ts

@@ -1,31 +1,24 @@
-import {
-  array,
-  type core,
-  length,
-  maxLength,
-  minLength,
-  type ZodMiniArray,
-} from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType } from './base.ts'
 
-type Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>
+type Check = zod.core.CheckFn<any[]> | zod.core.$ZodCheck<any[]>
 
 export class ArrayType<T extends BaseType = BaseType> extends BaseType<
-  ZodMiniArray<T['encodedZodType']>,
-  ZodMiniArray<T['decodedZodType']>,
+  zod.ZodMiniArray<T['encodedZodType']>,
+  zod.ZodMiniArray<T['decodedZodType']>,
   { element: T }
 > {
   static factory<T extends BaseType>(element: T, ...checks: Check[]) {
     return new ArrayType<T>({
-      encodedZodType: array(element.encodedZodType).check(...checks),
-      decodedZodType: array(element.decodedZodType).check(...checks),
+      encodedZodType: zod.array(element.encodedZodType).check(...checks),
+      decodedZodType: zod.array(element.decodedZodType).check(...checks),
       params: { checks },
       props: { element },
     })
   }
 
   min(value: number) {
-    const check = minLength(value)
+    const check = zod.minLength(value)
     return ArrayType.factory<T>(
       this.props.element,
       ...this.params.checks,
@@ -34,7 +27,7 @@ export class ArrayType<T extends BaseType = BaseType> extends BaseType<
   }
 
   max(value: number) {
-    const check = maxLength(value)
+    const check = zod.maxLength(value)
     return ArrayType.factory<T>(
       this.props.element,
       ...this.params.checks,
@@ -43,7 +36,7 @@ export class ArrayType<T extends BaseType = BaseType> extends BaseType<
   }
 
   length(value: number) {
-    const check = length(value)
+    const check = zod.length(value)
     return ArrayType.factory<T>(
       this.props.element,
       ...this.params.checks,
@@ -51,3 +44,5 @@ export class ArrayType<T extends BaseType = BaseType> extends BaseType<
     )
   }
 }
+
+export const array = ArrayType.factory