@nmtjs/type 0.10.1 → 0.10.3

package/dist/index.js

@@ -1,50 +1,8 @@
-import * as zod from "@zod/mini";
-import { AnyType } from "./types/any.js";
-import { ArrayType } from "./types/array.js";
-import { BooleanType } from "./types/boolean.js";
-import { CustomType } from "./types/custom.js";
-import { DateType } from "./types/date.js";
-import { EnumType } from "./types/enum.js";
-import { LiteralType } from "./types/literal.js";
-import { NeverType } from "./types/never.js";
-import { BigIntType, IntegerType, NumberType } from "./types/number.js";
-import { extend, keyof, merge, ObjectType, omit, partial, pick, RecordType } from "./types/object.js";
-import { StringType } from "./types/string.js";
-import { TupleType } from "./types/tuple.js";
-import { DiscriminatedUnionType, IntersactionType, UnionType } from "./types/union.js";
+import * as zod from "zod/v4-mini";
+import * as type from "./types/type.js";
 zod.config(zod.core.locales.en());
-export { NeemataTypeError } from "./types/base.js";
-export { BaseType } from "./types/base.js";
-export { AnyType, ArrayType, BooleanType, CustomType, DateType, EnumType, LiteralType, IntegerType, NumberType, ObjectType, StringType, IntersactionType, UnionType, TupleType, NeverType, DiscriminatedUnionType, RecordType };
-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.js";
+export { type, type as t };
 export default type;
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,YAAY,SAAS,WAAW;AAChC,SAAS,eAAe,gBAAgB;AACxC,SAAS,iBAAiB,kBAAkB;AAE5C,SAAS,mBAAmB,oBAAoB;AAChD,SAAS,kBAAkB,mBAAmB;AAC9C,SAAS,gBAAgB,iBAAiB;AAC1C,SAAS,gBAAgB,iBAAiB;AAC1C,SAAS,mBAAmB,oBAAoB;AAChD,SAAS,iBAAiB,kBAAkB;AAC5C,SAAS,YAAY,aAAa,kBAAkB,mBAAmB;AACvE,SACE,QACA,OACA,OACA,YACA,MACA,SACA,MACA,kBACK,mBAAmB;AAC1B,SAAS,kBAAkB,mBAAmB;AAC9C,SAAS,iBAAiB,kBAAkB;AAC5C,SACE,wBACA,kBACA,iBACK,kBAAkB;AAEzB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC;AAEjC,SAAS,wBAAwB;AACjC,SAAS,gBAAkC;AAC3C,SACE,SACA,WACA,aACA,YACA,UACA,UACA,aACA,aACA,YACA,YACA,YACA,kBACA,WACA,WACA,WACA,wBACA;AAqBF,OAAO,MAAM,OAAO;CAClB,OAAO,UAAU;CACjB,SAAS,YAAY;CACrB,QAAQ,WAAW;CACnB,QAAQ,WAAW;CACnB,SAAS,YAAY;CACrB,QAAQ,WAAW;CACnB,SAAS,YAAY;CACrB,MAAM,SAAS;CACf,OAAO,UAAU;CACjB,MAAM,SAAS;CACf,OAAO,UAAU;CACjB,QAAQ,WAAW;CACnB,KAAK,QAAQ;CACb,IAAI,UAAU;CACd,KAAK,iBAAiB;CACtB,OAAO,UAAU;CACjB,cAAc,iBAAiB;CAC/B,oBAAoB,uBAAuB;CAC3C,QAAQ,WAAW;CACnB,QAAQ,WAAW;CACnB;CACA;CACA;CACA;CACA;CACA;AACD;AACD,SAAS,QAAQ,GAAG;AACpB,eAAe","names":[],"sources":["../src/index.ts"],"sourcesContent":["import * as zod from '@zod/mini'\nimport { AnyType } from './types/any.ts'\nimport { ArrayType } from './types/array.ts'\nimport type { BaseTypeAny } from './types/base.ts'\nimport { BooleanType } from './types/boolean.ts'\nimport { CustomType } from './types/custom.ts'\nimport { DateType } from './types/date.ts'\nimport { EnumType } from './types/enum.ts'\nimport { LiteralType } from './types/literal.ts'\nimport { NeverType } from './types/never.ts'\nimport { BigIntType, IntegerType, NumberType } from './types/number.ts'\nimport {\n  extend,\n  keyof,\n  merge,\n  ObjectType,\n  omit,\n  partial,\n  pick,\n  RecordType,\n} from './types/object.ts'\nimport { StringType } from './types/string.ts'\nimport { TupleType } from './types/tuple.ts'\nimport {\n  DiscriminatedUnionType,\n  IntersactionType,\n  UnionType,\n} from './types/union.ts'\n\nzod.config(zod.core.locales.en())\n\nexport { NeemataTypeError } from './types/base.ts'\nexport { BaseType, type BaseTypeAny } from './types/base.ts'\nexport {\n  AnyType,\n  ArrayType,\n  BooleanType,\n  CustomType,\n  DateType,\n  EnumType,\n  LiteralType,\n  IntegerType,\n  NumberType,\n  ObjectType,\n  StringType,\n  IntersactionType,\n  UnionType,\n  TupleType,\n  NeverType,\n  DiscriminatedUnionType,\n  RecordType,\n}\n\nexport namespace type {\n  export 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}\n\nexport const type = {\n  never: NeverType.factory,\n  boolean: BooleanType.factory,\n  string: StringType.factory,\n  number: NumberType.factory,\n  integer: IntegerType.factory,\n  bigint: BigIntType.factory,\n  literal: LiteralType.factory,\n  enum: EnumType.factory,\n  tuple: TupleType.factory,\n  date: DateType.factory,\n  array: ArrayType.factory,\n  record: RecordType.factory,\n  any: AnyType.factory,\n  or: UnionType.factory,\n  and: IntersactionType.factory,\n  union: UnionType.factory,\n  intersaction: IntersactionType.factory,\n  discriminatedUnion: DiscriminatedUnionType.factory,\n  custom: CustomType.factory,\n  object: ObjectType.factory,\n  keyof,\n  partial,\n  merge,\n  omit,\n  extend,\n  pick,\n}\nexport { type as t, zod }\nexport default type\n"],"version":3,"file":"index.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,YAAY,UAAU,iBAAiB;AAEvC,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC;AAEjC,cAAc;AACd,SAAS,MAAM,QAAQ;AACvB,eAAe","names":[],"sources":["../src/index.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport * as type from './types/type.ts'\n\nzod.config(zod.core.locales.en())\n\nexport * from './types/base.ts'\nexport { type, type as t }\nexport default type\n"],"version":3,"file":"index.js"}

package/dist/temporal.js

@@ -1,10 +1,3 @@
-import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType } from "./types/temporal.js";
-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 * from "./types/temporal.js";
 
 //# sourceMappingURL=temporal.js.map

package/dist/temporal.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SACE,cACA,mBACA,eACA,mBACA,eACA,oBACA,yBACK,qBAAqB;AAE5B,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":[],"sources":["../src/temporal.ts"],"sourcesContent":["import {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n} from './types/temporal.ts'\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\nexport type {\n  DurationType,\n  PlainDateTimeType,\n  PlainDateType,\n  PlainMonthDayType,\n  PlainTimeType,\n  PlainYearMonthType,\n  ZonedDateTimeType,\n}\n"],"version":3,"file":"temporal.js"}
+{"mappings":"AAAA,cAAc","names":[],"sources":["../src/temporal.ts"],"sourcesContent":["export * from './types/temporal.ts'\n"],"version":3,"file":"temporal.js"}

package/dist/types/any.js

@@ -1,9 +1,10 @@
-import { any } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 export class AnyType extends BaseType {
 	static factory() {
-		return new AnyType({ encodedZodType: any() });
+		return new AnyType({ encodedZodType: zod.any() });
 	}
 }
+export const any = AnyType.factory;
 
 //# sourceMappingURL=any.js.map

package/dist/types/any.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,WAA4B,WAAW;AAChD,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,gBAAgB,SAAqB;CAChD,OAAO,UAAU;AACf,SAAO,IAAI,QAAQ,EACjB,gBAAgB,KAAK,CACtB;CACF;AACF","names":[],"sources":["../../src/types/any.ts"],"sourcesContent":["import { any, type ZodMiniAny } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class AnyType extends BaseType<ZodMiniAny> {\n  static factory() {\n    return new AnyType({\n      encodedZodType: any(),\n    })\n  }\n}\n"],"version":3,"file":"any.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,gBAAgB,SAAyB;CACpD,OAAO,UAAU;AACf,SAAO,IAAI,QAAQ,EACjB,gBAAgB,IAAI,KAAK,CAC1B;CACF;AACF;AAED,OAAO,MAAM,MAAM,QAAQ","names":[],"sources":["../../src/types/any.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType } from './base.ts'\n\nexport class AnyType extends BaseType<zod.ZodMiniAny> {\n  static factory() {\n    return new AnyType({\n      encodedZodType: zod.any(),\n    })\n  }\n}\n\nexport const any = AnyType.factory\n"],"version":3,"file":"any.js"}

package/dist/types/array.js

@@ -1,26 +1,27 @@
-import { array, length, maxLength, minLength } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 export class ArrayType extends BaseType {
 	static factory(element, ...checks) {
 		return new ArrayType({
-			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) {
-		const check = minLength(value);
+		const check = zod.minLength(value);
 		return ArrayType.factory(this.props.element, ...this.params.checks, check);
 	}
 	max(value) {
-		const check = maxLength(value);
+		const check = zod.maxLength(value);
 		return ArrayType.factory(this.props.element, ...this.params.checks, check);
 	}
 	length(value) {
-		const check = length(value);
+		const check = zod.length(value);
 		return ArrayType.factory(this.props.element, ...this.params.checks, check);
 	}
 }
+export const array = ArrayType.factory;
 
 //# sourceMappingURL=array.js.map

package/dist/types/array.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SACE,OAEA,QACA,WACA,iBAEK,WAAW;AAClB,SAAS,gBAAgB,WAAW;AAIpC,OAAO,MAAM,kBAAiD,SAI5D;CACA,OAAO,QAA4BA,SAAY,GAAG,QAAiB;AACjE,SAAO,IAAI,UAAa;GACtB,gBAAgB,MAAM,QAAQ,eAAe,CAAC,MAAM,GAAG,OAAO;GAC9D,gBAAgB,MAAM,QAAQ,eAAe,CAAC,MAAM,GAAG,OAAO;GAC9D,QAAQ,EAAE,OAAQ;GAClB,OAAO,EAAE,QAAS;EACnB;CACF;CAED,IAAIC,OAAe;EACjB,MAAM,QAAQ,UAAU,MAAM;AAC9B,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;CAED,IAAIA,OAAe;EACjB,MAAM,QAAQ,UAAU,MAAM;AAC9B,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;CAED,OAAOA,OAAe;EACpB,MAAM,QAAQ,OAAO,MAAM;AAC3B,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;AACF","names":["element: T","value: number"],"sources":["../../src/types/array.ts"],"sourcesContent":["import {\n  array,\n  type core,\n  length,\n  maxLength,\n  minLength,\n  type ZodMiniArray,\n} from '@zod/mini'\nimport { BaseType } from './base.ts'\n\ntype Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>\n\nexport class ArrayType<T extends BaseType = BaseType> extends BaseType<\n  ZodMiniArray<T['encodedZodType']>,\n  ZodMiniArray<T['decodedZodType']>,\n  { element: T }\n> {\n  static factory<T extends BaseType>(element: T, ...checks: Check[]) {\n    return new ArrayType<T>({\n      encodedZodType: array(element.encodedZodType).check(...checks),\n      decodedZodType: array(element.decodedZodType).check(...checks),\n      params: { checks },\n      props: { element },\n    })\n  }\n\n  min(value: number) {\n    const check = minLength(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n\n  max(value: number) {\n    const check = maxLength(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n\n  length(value: number) {\n    const check = length(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n}\n"],"version":3,"file":"array.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAgB,WAAW;AAIpC,OAAO,MAAM,kBAAiD,SAI5D;CACA,OAAO,QAA4BA,SAAY,GAAG,QAAiB;AACjE,SAAO,IAAI,UAAa;GACtB,gBAAgB,IAAI,MAAM,QAAQ,eAAe,CAAC,MAAM,GAAG,OAAO;GAClE,gBAAgB,IAAI,MAAM,QAAQ,eAAe,CAAC,MAAM,GAAG,OAAO;GAClE,QAAQ,EAAE,OAAQ;GAClB,OAAO,EAAE,QAAS;EACnB;CACF;CAED,IAAIC,OAAe;EACjB,MAAM,QAAQ,IAAI,UAAU,MAAM;AAClC,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;CAED,IAAIA,OAAe;EACjB,MAAM,QAAQ,IAAI,UAAU,MAAM;AAClC,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;CAED,OAAOA,OAAe;EACpB,MAAM,QAAQ,IAAI,OAAO,MAAM;AAC/B,SAAO,UAAU,QACf,KAAK,MAAM,SACX,GAAG,KAAK,OAAO,QACf,MACD;CACF;AACF;AAED,OAAO,MAAM,QAAQ,UAAU","names":["element: T","value: number"],"sources":["../../src/types/array.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType } from './base.ts'\n\ntype Check = zod.core.CheckFn<any[]> | zod.core.$ZodCheck<any[]>\n\nexport class ArrayType<T extends BaseType = BaseType> extends BaseType<\n  zod.ZodMiniArray<T['encodedZodType']>,\n  zod.ZodMiniArray<T['decodedZodType']>,\n  { element: T }\n> {\n  static factory<T extends BaseType>(element: T, ...checks: Check[]) {\n    return new ArrayType<T>({\n      encodedZodType: zod.array(element.encodedZodType).check(...checks),\n      decodedZodType: zod.array(element.decodedZodType).check(...checks),\n      params: { checks },\n      props: { element },\n    })\n  }\n\n  min(value: number) {\n    const check = zod.minLength(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n\n  max(value: number) {\n    const check = zod.maxLength(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n\n  length(value: number) {\n    const check = zod.length(value)\n    return ArrayType.factory<T>(\n      this.props.element,\n      ...this.params.checks,\n      check,\n    )\n  }\n}\n\nexport const array = ArrayType.factory\n"],"version":3,"file":"array.js"}

package/dist/types/base.js

@@ -1,6 +1,6 @@
-import { _default, core, nullable, optional, registry } from "@zod/mini";
-export const typesRegistry = registry();
-export const NeemataTypeError = core.$ZodError;
+import * as zod from "zod/v4-mini";
+export const typesRegistry = zod.registry();
+export const NeemataTypeError = zod.core.$ZodError;
 export class BaseType {
 	encodedZodType;
 	decodedZodType;
@@ -49,7 +49,7 @@ export class BaseType {
 export class OptionalType extends BaseType {
 	static factory(type) {
 		return new OptionalType({
-			encodedZodType: optional(type.encodedZodType),
+			encodedZodType: zod.optional(type.encodedZodType),
 			props: { inner: type }
 		});
 	}
@@ -57,7 +57,7 @@ export class OptionalType extends BaseType {
 export class NullableType extends BaseType {
 	static factory(type) {
 		return new NullableType({
-			encodedZodType: nullable(type.encodedZodType),
+			encodedZodType: zod.nullable(type.encodedZodType),
 			props: { inner: type }
 		});
 	}
@@ -65,8 +65,8 @@ export class NullableType extends BaseType {
 export class DefaultType extends BaseType {
 	static factory(type, defaultValue) {
 		return new DefaultType({
-			encodedZodType: _default(type.encodedZodType, type.params.encode?.(defaultValue) ?? defaultValue),
-			decodedZodType: _default(type.decodedZodType, defaultValue),
+			encodedZodType: zod._default(type.encodedZodType, type.params.encode?.(defaultValue) ?? defaultValue),
+			decodedZodType: zod._default(type.decodedZodType, defaultValue),
 			props: { inner: type }
 		});
 	}

package/dist/types/base.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SACE,UACA,MACA,UACA,UACA,gBAoBK,WAAW;AAmDlB,OAAO,MAAM,gBAAgB,UAAwB;AAErD,OAAO,MAAM,mBAAmB,KAAK;AAGrC,OAAO,MAAe,SAIpB;CACA,AAAS;CACT,AAAS;CACT,AAAS;CACT,AAAS;CAET,YAAY,EACV,gBACA,iBAAiB,gBACjB,QAAQ,CAAE,GACV,SAAS,CAAE,GAMZ,EAAE;AACD,OAAK,iBAAiB;AACtB,OAAK,iBAAiB;AAEtB,OAAK,QAAQ;AACb,OAAK,SAAS,OAAO,OAAO,EAAE,QAAQ,CAAE,EAAE,GAAE,OAAO;CACpD;CAED,WAA+B;AAC7B,SAAO,aAAa,QAAQ,KAAK;CAClC;CAED,WAA+B;AAC7B,SAAO,aAAa,QAAQ,KAAK;CAClC;CAED,UAAU;AACR,SAAO,KAAK,UAAU,CAAC,UAAU;CAClC;CAED,QAAQA,OAAmE;AACzE,SAAO,YAAY,QAAQ,MAAM,MAAM;CACxC;CAED,MAAMC,OAAqB;AACzB,SAAO,KAAK,KAAK,EAAE,MAAO,EAAC;CAC5B;CAED,YAAYC,aAA2B;AACrC,SAAO,KAAK,KAAK,EAAE,YAAa,EAAC;CAClC;CAED,SAAS,GAAG,UAA2D;AACrE,SAAO,KAAK,KAAK,EACf,UAAU,KAAK,OAAO,SAClB,SAAS,IAAI,KAAK,OAAO,OAAO,GAChC,SACL,EAAC;CACH;CAED,KAAKC,aAAiC;EACpC,MAAM,WAAW,cAAc,IAAI,KAAK,eAAe,IAAI,CAAE;AAC7D,SAAO,OAAO,UAAU,YAAY;AACpC,gBAAc,IAAI,KAAK,gBAAgB,SAAS;AAChD,SAAO;CACR;CAED,OACEC,MAC0C;AAC1C,SAAO,KAAK,eAAe,MAAM,MAAM,EAAE,aAAa,KAAM,EAAC;CAC9D;CAED,OACEC,MAC0C;AAC1C,SAAO,KAAK,eAAe,MAAM,MAAM,EAAE,aAAa,KAAM,EAAC;CAC9D;AACF;AAED,OAAO,MAAM,qBAEH,SAIR;CACA,OAAO,QAA+BC,MAAS;AAC7C,SAAO,IAAI,aAAgB;GACzB,gBAAgB,SAAS,KAAK,eAAe;GAC7C,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF;AAED,OAAO,MAAM,qBAEH,SAIR;CACA,OAAO,QAAoCA,MAAS;AAClD,SAAO,IAAI,aAAgB;GACzB,gBAAgB,SAAS,KAAK,eAAe;GAC7C,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF;AAED,OAAO,MAAM,oBAEH,SAIR;CACA,OAAO,QAAoCA,MAASC,cAAmB;AACrE,SAAO,IAAI,YAAe;GACxB,gBAAgB,SACd,KAAK,gBACL,KAAK,OAAO,SAAS,aAAa,IAAI,aACvC;GACD,gBAAgB,SAAS,KAAK,gBAAgB,aAAa;GAC3D,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF","names":["value: this['encodedZodType']['_zod']['input']","title: string","description: string","newMetadata: TypeMetadata","data: this['encodedZodType']['_zod']['input']","data: this['decodedZodType']['_zod']['input']","type: T","defaultValue: any"],"sources":["../../src/types/base.ts"],"sourcesContent":["import {\n  _default,\n  core,\n  nullable,\n  optional,\n  registry,\n  type ZodMiniAny,\n  type ZodMiniArray,\n  type ZodMiniBoolean,\n  type ZodMiniCustom,\n  type ZodMiniDefault,\n  type ZodMiniEnum,\n  type ZodMiniInterface,\n  type ZodMiniIntersection,\n  type ZodMiniLiteral,\n  type ZodMiniNever,\n  type ZodMiniNullable,\n  type ZodMiniNumber,\n  type ZodMiniObject,\n  type ZodMiniOptional,\n  type ZodMiniPipe,\n  type ZodMiniRecord,\n  type ZodMiniString,\n  type ZodMiniType,\n  type ZodMiniUnion,\n} from '@zod/mini'\n\nexport type PrimitiveValueType = string | number | boolean | null\n\nexport type PrimitiveZodType =\n  | ZodMiniNever\n  | ZodMiniDefault\n  | ZodMiniNullable\n  | ZodMiniOptional\n  | ZodMiniString\n  | ZodMiniObject\n  | ZodMiniAny\n  | ZodMiniArray\n  | ZodMiniBoolean\n  | ZodMiniNumber\n  | ZodMiniEnum<any>\n  | ZodMiniLiteral<PrimitiveValueType>\n  | ZodMiniUnion\n  | ZodMiniIntersection\n  | ZodMiniInterface\n  | ZodMiniRecord\n\nexport type SimpleZodType = ZodMiniType\n\nexport type ZodType = SimpleZodType | ZodMiniType\n\nexport type TypeProps = Record<string, any>\n\nexport type TypeMetadata<T = any> = {\n  id?: string\n  description?: string\n  examples?: T[]\n  title?: string\n}\n\nexport type TypeParams = {\n  encode?: (value: any) => any\n  metadata?: TypeMetadata\n  checks: Array<core.CheckFn<any> | core.$ZodCheck<any>>\n}\n\nexport type DefaultTypeParams = {\n  encode?: TypeParams['encode']\n  metadata?: TypeMetadata\n}\n\nexport type BaseTypeAny<\n  EncodedZodType extends SimpleZodType = SimpleZodType,\n  DecodedZodType extends ZodType = ZodMiniType,\n> = BaseType<EncodedZodType, DecodedZodType, TypeProps>\n\nexport const typesRegistry = registry<TypeMetadata>()\n\nexport const NeemataTypeError = core.$ZodError\nexport type NeemataTypeError = core.$ZodError\n\nexport abstract class BaseType<\n  EncodedZodType extends SimpleZodType = SimpleZodType,\n  DecodedZodType extends ZodType = EncodedZodType,\n  Props extends TypeProps = TypeProps,\n> {\n  readonly encodedZodType: EncodedZodType\n  readonly decodedZodType: DecodedZodType\n  readonly props: Props\n  readonly params: TypeParams\n\n  constructor({\n    encodedZodType,\n    decodedZodType = encodedZodType as unknown as DecodedZodType,\n    props = {} as Props,\n    params = {} as Partial<TypeParams>,\n  }: {\n    encodedZodType: EncodedZodType\n    decodedZodType?: DecodedZodType\n    props?: Props\n    params?: Partial<TypeParams>\n  }) {\n    this.encodedZodType = encodedZodType\n    this.decodedZodType = decodedZodType\n\n    this.props = props\n    this.params = Object.assign({ checks: [] }, params)\n  }\n\n  optional(): OptionalType<this> {\n    return OptionalType.factory(this)\n  }\n\n  nullable(): NullableType<this> {\n    return NullableType.factory(this)\n  }\n\n  nullish() {\n    return this.nullable().optional()\n  }\n\n  default(value: this['encodedZodType']['_zod']['input']): DefaultType<this> {\n    return DefaultType.factory(this, value)\n  }\n\n  title(title: string): this {\n    return this.meta({ title })\n  }\n\n  description(description: string): this {\n    return this.meta({ description })\n  }\n\n  examples(...examples: this['decodedZodType']['_zod']['input'][]): this {\n    return this.meta({\n      examples: this.params.encode\n        ? examples.map(this.params.encode)\n        : examples,\n    })\n  }\n\n  meta(newMetadata: TypeMetadata): this {\n    const metadata = typesRegistry.get(this.encodedZodType) ?? {}\n    Object.assign(metadata, newMetadata)\n    typesRegistry.add(this.encodedZodType, metadata)\n    return this\n  }\n\n  encode(\n    data: this['encodedZodType']['_zod']['input'],\n  ): this['encodedZodType']['_zod']['output'] {\n    return this.encodedZodType.parse(data, { reportInput: true })\n  }\n\n  decode(\n    data: this['decodedZodType']['_zod']['input'],\n  ): this['decodedZodType']['_zod']['output'] {\n    return this.decodedZodType.parse(data, { reportInput: true })\n  }\n}\n\nexport class OptionalType<\n  Type extends BaseTypeAny = BaseTypeAny,\n> extends BaseType<\n  ZodMiniOptional<Type['encodedZodType']>,\n  ZodMiniOptional<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny>(type: T) {\n    return new OptionalType<T>({\n      encodedZodType: optional(type.encodedZodType) as any,\n      props: { inner: type },\n    })\n  }\n}\n\nexport class NullableType<\n  Type extends BaseTypeAny<any> = BaseTypeAny<any>,\n> extends BaseType<\n  ZodMiniNullable<Type['encodedZodType']>,\n  ZodMiniNullable<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new NullableType<T>({\n      encodedZodType: nullable(type.encodedZodType),\n      props: { inner: type },\n    })\n  }\n}\n\nexport class DefaultType<\n  Type extends BaseTypeAny = BaseTypeAny,\n> extends BaseType<\n  ZodMiniDefault<Type['encodedZodType']>,\n  ZodMiniDefault<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {\n    return new DefaultType<T>({\n      encodedZodType: _default(\n        type.encodedZodType,\n        type.params.encode?.(defaultValue) ?? defaultValue,\n      ) as any,\n      decodedZodType: _default(type.decodedZodType, defaultValue) as any,\n      props: { inner: type },\n    })\n  }\n}\n"],"version":3,"file":"base.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAkDlC,OAAO,MAAM,gBAAgB,IAAI,UAAwB;AAEzD,OAAO,MAAM,mBAAmB,IAAI,KAAK;AAGzC,OAAO,MAAe,SAIpB;CACA,AAAS;CACT,AAAS;CACT,AAAS;CACT,AAAS;CAET,YAAY,EACV,gBACA,iBAAiB,gBACjB,QAAQ,CAAE,GACV,SAAS,CAAE,GAMZ,EAAE;AACD,OAAK,iBAAiB;AACtB,OAAK,iBAAiB;AAEtB,OAAK,QAAQ;AACb,OAAK,SAAS,OAAO,OAAO,EAAE,QAAQ,CAAE,EAAE,GAAE,OAAO;CACpD;CAED,WAA+B;AAC7B,SAAO,aAAa,QAAQ,KAAK;CAClC;CAED,WAA+B;AAC7B,SAAO,aAAa,QAAQ,KAAK;CAClC;CAED,UAAU;AACR,SAAO,KAAK,UAAU,CAAC,UAAU;CAClC;CAED,QAAQA,OAAmE;AACzE,SAAO,YAAY,QAAQ,MAAM,MAAM;CACxC;CAED,MAAMC,OAAqB;AACzB,SAAO,KAAK,KAAK,EAAE,MAAO,EAAC;CAC5B;CAED,YAAYC,aAA2B;AACrC,SAAO,KAAK,KAAK,EAAE,YAAa,EAAC;CAClC;CAED,SAAS,GAAG,UAA2D;AACrE,SAAO,KAAK,KAAK,EACf,UAAU,KAAK,OAAO,SAClB,SAAS,IAAI,KAAK,OAAO,OAAO,GAChC,SACL,EAAC;CACH;CAED,KAAKC,aAAiC;EACpC,MAAM,WAAW,cAAc,IAAI,KAAK,eAAe,IAAI,CAAE;AAC7D,SAAO,OAAO,UAAU,YAAY;AACpC,gBAAc,IAAI,KAAK,gBAAgB,SAAS;AAChD,SAAO;CACR;CAED,OACEC,MAC0C;AAC1C,SAAO,KAAK,eAAe,MAAM,MAAM,EAAE,aAAa,KAAM,EAAC;CAC9D;CAED,OACEC,MAC0C;AAC1C,SAAO,KAAK,eAAe,MAAM,MAAM,EAAE,aAAa,KAAM,EAAC;CAC9D;AACF;AAED,OAAO,MAAM,qBAEH,SAIR;CACA,OAAO,QAA+BC,MAAS;AAC7C,SAAO,IAAI,aAAgB;GACzB,gBAAgB,IAAI,SAAS,KAAK,eAAe;GACjD,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF;AAED,OAAO,MAAM,qBAEH,SAIR;CACA,OAAO,QAAoCA,MAAS;AAClD,SAAO,IAAI,aAAgB;GACzB,gBAAgB,IAAI,SAAS,KAAK,eAAe;GACjD,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF;AAED,OAAO,MAAM,oBAEH,SAIR;CACA,OAAO,QAAoCA,MAASC,cAAmB;AACrE,SAAO,IAAI,YAAe;GACxB,gBAAgB,IAAI,SAClB,KAAK,gBACL,KAAK,OAAO,SAAS,aAAa,IAAI,aACvC;GACD,gBAAgB,IAAI,SAAS,KAAK,gBAAgB,aAAa;GAC/D,OAAO,EAAE,OAAO,KAAM;EACvB;CACF;AACF","names":["value: this['encodedZodType']['_zod']['input']","title: string","description: string","newMetadata: TypeMetadata","data: this['encodedZodType']['_zod']['input']","data: this['decodedZodType']['_zod']['input']","type: T","defaultValue: any"],"sources":["../../src/types/base.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\n\nexport type PrimitiveValueType = string | number | boolean | null\n\nexport type PrimitiveZodType =\n  | zod.ZodMiniNever\n  | zod.ZodMiniDefault\n  | zod.ZodMiniNullable\n  | zod.ZodMiniOptional\n  | zod.ZodMiniString\n  | zod.ZodMiniObject\n  | zod.ZodMiniAny\n  | zod.ZodMiniArray\n  | zod.ZodMiniBoolean\n  | zod.ZodMiniNumber\n  | zod.ZodMiniEnum<any>\n  | zod.ZodMiniLiteral<PrimitiveValueType>\n  | zod.ZodMiniUnion\n  | zod.ZodMiniIntersection\n  | zod.ZodMiniRecord\n\nexport type SimpleZodType = zod.ZodMiniType\n\nexport type ZodType = SimpleZodType | zod.ZodMiniType\n\nexport type TypeProps = Record<string, any>\n\nexport type TypeMetadata<T = any> = {\n  id?: string\n  description?: string\n  examples?: T[]\n  title?: string\n}\n\nexport type TypeParams = {\n  encode?: (value: any) => any\n  metadata?: TypeMetadata\n  checks: Array<zod.core.CheckFn<any> | zod.core.$ZodCheck<any>>\n}\n\nexport type DefaultTypeParams = {\n  encode?: TypeParams['encode']\n  metadata?: TypeMetadata\n}\n\nexport type BaseTypeAny<\n  EncodedZodType extends SimpleZodType = SimpleZodType,\n  DecodedZodType extends ZodType = zod.ZodMiniType,\n> = BaseType<EncodedZodType, DecodedZodType, TypeProps>\n\nexport const typesRegistry = zod.registry<TypeMetadata>()\n\nexport const NeemataTypeError = zod.core.$ZodError\nexport type NeemataTypeError = zod.core.$ZodError\n\nexport abstract class BaseType<\n  EncodedZodType extends SimpleZodType = SimpleZodType,\n  DecodedZodType extends ZodType = EncodedZodType,\n  Props extends TypeProps = TypeProps,\n> {\n  readonly encodedZodType: EncodedZodType\n  readonly decodedZodType: DecodedZodType\n  readonly props: Props\n  readonly params: TypeParams\n\n  constructor({\n    encodedZodType,\n    decodedZodType = encodedZodType as unknown as DecodedZodType,\n    props = {} as Props,\n    params = {} as Partial<TypeParams>,\n  }: {\n    encodedZodType: EncodedZodType\n    decodedZodType?: DecodedZodType\n    props?: Props\n    params?: Partial<TypeParams>\n  }) {\n    this.encodedZodType = encodedZodType\n    this.decodedZodType = decodedZodType\n\n    this.props = props\n    this.params = Object.assign({ checks: [] }, params)\n  }\n\n  optional(): OptionalType<this> {\n    return OptionalType.factory(this)\n  }\n\n  nullable(): NullableType<this> {\n    return NullableType.factory(this)\n  }\n\n  nullish() {\n    return this.nullable().optional()\n  }\n\n  default(value: this['encodedZodType']['_zod']['input']): DefaultType<this> {\n    return DefaultType.factory(this, value)\n  }\n\n  title(title: string): this {\n    return this.meta({ title })\n  }\n\n  description(description: string): this {\n    return this.meta({ description })\n  }\n\n  examples(...examples: this['decodedZodType']['_zod']['input'][]): this {\n    return this.meta({\n      examples: this.params.encode\n        ? examples.map(this.params.encode)\n        : examples,\n    })\n  }\n\n  meta(newMetadata: TypeMetadata): this {\n    const metadata = typesRegistry.get(this.encodedZodType) ?? {}\n    Object.assign(metadata, newMetadata)\n    typesRegistry.add(this.encodedZodType, metadata)\n    return this\n  }\n\n  encode(\n    data: this['encodedZodType']['_zod']['input'],\n  ): this['encodedZodType']['_zod']['output'] {\n    return this.encodedZodType.parse(data, { reportInput: true })\n  }\n\n  decode(\n    data: this['decodedZodType']['_zod']['input'],\n  ): this['decodedZodType']['_zod']['output'] {\n    return this.decodedZodType.parse(data, { reportInput: true })\n  }\n}\n\nexport class OptionalType<\n  Type extends BaseTypeAny = BaseTypeAny,\n> extends BaseType<\n  zod.ZodMiniOptional<Type['encodedZodType']>,\n  zod.ZodMiniOptional<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny>(type: T) {\n    return new OptionalType<T>({\n      encodedZodType: zod.optional(type.encodedZodType) as any,\n      props: { inner: type },\n    })\n  }\n}\n\nexport class NullableType<\n  Type extends BaseTypeAny<any> = BaseTypeAny<any>,\n> extends BaseType<\n  zod.ZodMiniNullable<Type['encodedZodType']>,\n  zod.ZodMiniNullable<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T) {\n    return new NullableType<T>({\n      encodedZodType: zod.nullable(type.encodedZodType),\n      props: { inner: type },\n    })\n  }\n}\n\nexport class DefaultType<\n  Type extends BaseTypeAny = BaseTypeAny,\n> extends BaseType<\n  zod.ZodMiniDefault<Type['encodedZodType']>,\n  zod.ZodMiniDefault<Type['decodedZodType']>,\n  { inner: Type }\n> {\n  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {\n    return new DefaultType<T>({\n      encodedZodType: zod._default(\n        type.encodedZodType,\n        type.params.encode?.(defaultValue) ?? defaultValue,\n      ) as any,\n      decodedZodType: zod._default(type.decodedZodType, defaultValue) as any,\n      props: { inner: type },\n    })\n  }\n}\n"],"version":3,"file":"base.js"}

package/dist/types/boolean.js

@@ -1,9 +1,10 @@
-import { boolean } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 export class BooleanType extends BaseType {
 	static factory() {
-		return new BooleanType({ encodedZodType: boolean() });
+		return new BooleanType({ encodedZodType: zod.boolean() });
 	}
 }
+export const boolean = BooleanType.factory;
 
 //# sourceMappingURL=boolean.js.map

package/dist/types/boolean.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,eAAoC,WAAW;AACxD,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,oBAAoB,SAAkC;CACjE,OAAO,UAAU;AACf,SAAO,IAAI,YAAY,EACrB,gBAAgB,SAAS,CAC1B;CACF;AACF","names":[],"sources":["../../src/types/boolean.ts"],"sourcesContent":["import { boolean, type ZodMiniBoolean } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class BooleanType extends BaseType<ZodMiniBoolean<boolean>> {\n  static factory() {\n    return new BooleanType({\n      encodedZodType: boolean(),\n    })\n  }\n}\n"],"version":3,"file":"boolean.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,oBAAoB,SAAsC;CACrE,OAAO,UAAU;AACf,SAAO,IAAI,YAAY,EACrB,gBAAgB,IAAI,SAAS,CAC9B;CACF;AACF;AAED,OAAO,MAAM,UAAU,YAAY","names":[],"sources":["../../src/types/boolean.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType } from './base.ts'\n\nexport class BooleanType extends BaseType<zod.ZodMiniBoolean<boolean>> {\n  static factory() {\n    return new BooleanType({\n      encodedZodType: zod.boolean(),\n    })\n  }\n}\n\nexport const boolean = BooleanType.factory\n"],"version":3,"file":"boolean.js"}

package/dist/types/custom.js

@@ -1,20 +1,25 @@
-import { any, custom, overwrite, pipe, refine } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 export class TransformType extends BaseType {}
 export class CustomType extends TransformType {
-	static factory({ decode, encode, error, type = any() }) {
+	static factory({ decode, encode, error, type = zod.any() }) {
 		return new CustomType({
-			encodedZodType: pipe(custom().check(refine((val) => typeof val !== "undefined", {
+			encodedZodType: zod.pipe(zod.custom().check(zod.refine((val) => typeof val !== "undefined", {
 				error,
 				abort: true
-			}), overwrite(encode)), type),
-			decodedZodType: pipe(type, custom().check(refine((val) => typeof val !== "undefined", {
-				error,
-				abort: true
-			}), overwrite(decode))),
+			}), zod.overwrite(encode)), type),
+			decodedZodType: zod.pipe(
+				type,
+				// @ts-expect-error
+				zod.custom().check(zod.refine((val) => typeof val !== "undefined", {
+					error,
+					abort: true
+				}), zod.overwrite(decode))
+),
 			params: { encode }
 		});
 	}
 }
+export const custom = CustomType.factory;
 
 //# sourceMappingURL=custom.js.map

package/dist/types/custom.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SACE,KAEA,QACA,WACA,MACA,cAGK,WAAW;AAClB,SAAS,gBAAkD,WAAW;AAGtE,OAAO,MAAe,sBAIZ,SASR,CAAE;AAEJ,OAAO,MAAM,mBAIH,cAA8C;CACtD,OAAO,QAIL,EACA,QACA,QACA,OACA,OAAO,KAAK,EAYb,EAAE;AACD,SAAO,IAAI,WAA2C;GACpD,gBAAgB,KACd,QAAQ,CAAC,MACP,OAAO,CAAC,eAAe,QAAQ,aAAa;IAAE;IAAO,OAAO;GAAM,EAAC,EACnE,UAAU,OAAO,CAClB,EACD,KACD;GACD,gBAAgB,KACd,MACA,QAAQ,CAAC,MACP,OAAO,CAAC,eAAe,QAAQ,aAAa;IAAE;IAAO,OAAO;GAAM,EAAC,EACnE,UAAU,OAAO,CAClB,CACF;GACD,QAAQ,EAAE,OAAQ;EACnB;CACF;AACF","names":[],"sources":["../../src/types/custom.ts"],"sourcesContent":["import {\n  any,\n  type core,\n  custom,\n  overwrite,\n  pipe,\n  refine,\n  type ZodMiniPipe,\n  type ZodMiniType,\n} from '@zod/mini'\nimport { BaseType, type SimpleZodType, type ZodType } from './base.ts'\n\nexport type CustomTransformFn<I, O> = (value: I) => O\nexport abstract class TransformType<\n  Type,\n  EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,\n  DecodedType extends ZodType = ZodMiniType<Type, Type>,\n> extends BaseType<\n  ZodMiniPipe<\n    ZodMiniType<DecodedType['_zod']['output'], DecodedType['_zod']['input']>,\n    EncodedType\n  >,\n  ZodMiniPipe<\n    EncodedType,\n    ZodMiniType<EncodedType['_zod']['output'], EncodedType['_zod']['input']>\n  >\n> {}\n\nexport class CustomType<\n  Type,\n  EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,\n  DecodedType extends ZodType = ZodMiniType<Type, Type>,\n> extends TransformType<Type, EncodedType, DecodedType> {\n  static factory<\n    Type,\n    EncodedType extends SimpleZodType = ZodMiniType<Type, Type>,\n    DecodedType extends ZodType = ZodMiniType<Type, Type>,\n  >({\n    decode,\n    encode,\n    error,\n    type = any() as unknown as EncodedType,\n  }: {\n    decode: CustomTransformFn<\n      EncodedType['_zod']['input'],\n      DecodedType['_zod']['output']\n    >\n    encode: CustomTransformFn<\n      DecodedType['_zod']['input'],\n      EncodedType['_zod']['output']\n    >\n    error?: string | core.$ZodErrorMap<core.$ZodIssueBase>\n    type?: EncodedType\n  }) {\n    return new CustomType<Type, EncodedType, DecodedType>({\n      encodedZodType: pipe(\n        custom().check(\n          refine((val) => typeof val !== 'undefined', { error, abort: true }),\n          overwrite(encode),\n        ),\n        type,\n      ),\n      decodedZodType: pipe(\n        type,\n        custom().check(\n          refine((val) => typeof val !== 'undefined', { error, abort: true }),\n          overwrite(decode),\n        ),\n      ),\n      params: { encode },\n    })\n  }\n}\n"],"version":3,"file":"custom.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAkD,WAAW;AAGtE,OAAO,MAAe,sBAIZ,SAYR,CAAE;AAEJ,OAAO,MAAM,mBAIH,cAA8C;CACtD,OAAO,QAIL,EACA,QACA,QACA,OACA,OAAO,IAAI,KAAK,EAYjB,EAAE;AACD,SAAO,IAAI,WAA2C;GACpD,gBAAgB,IAAI,KAClB,IAAI,QAAQ,CAAC,MACX,IAAI,OAAO,CAAC,eAAe,QAAQ,aAAa;IAC9C;IACA,OAAO;GACR,EAAC,EACF,IAAI,UAAU,OAAO,CACtB,EACD,KACD;GAED,gBAAgB,IAAI;IAClB;;IAEA,IACG,QAAQ,CACR,MACC,IAAI,OAAO,CAAC,eAAe,QAAQ,aAAa;KAC9C;KACA,OAAO;IACR,EAAC,EACF,IAAI,UAAU,OAAO,CACtB;CACJ;GACD,QAAQ,EAAE,OAAQ;EACnB;CACF;AACF;AAED,OAAO,MAAM,SAAS,WAAW","names":[],"sources":["../../src/types/custom.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType, type SimpleZodType, type ZodType } from './base.ts'\n\nexport type CustomTransformFn<I, O> = (value: I) => O\nexport abstract class TransformType<\n  Type,\n  EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,\n  DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,\n> extends BaseType<\n  zod.ZodMiniPipe<\n    zod.ZodMiniType<\n      DecodedType['_zod']['output'],\n      DecodedType['_zod']['input']\n    >,\n    EncodedType\n  >,\n  zod.ZodMiniPipe<\n    EncodedType,\n    zod.ZodMiniType<EncodedType['_zod']['output'], EncodedType['_zod']['input']>\n  >\n> {}\n\nexport class CustomType<\n  Type,\n  EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,\n  DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,\n> extends TransformType<Type, EncodedType, DecodedType> {\n  static factory<\n    Type,\n    EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,\n    DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,\n  >({\n    decode,\n    encode,\n    error,\n    type = zod.any() as unknown as EncodedType,\n  }: {\n    decode: CustomTransformFn<\n      EncodedType['_zod']['input'],\n      DecodedType['_zod']['output']\n    >\n    encode: CustomTransformFn<\n      DecodedType['_zod']['input'],\n      EncodedType['_zod']['output']\n    >\n    error?: string | zod.core.$ZodErrorMap<zod.core.$ZodIssueBase>\n    type?: EncodedType\n  }) {\n    return new CustomType<Type, EncodedType, DecodedType>({\n      encodedZodType: zod.pipe(\n        zod.custom().check(\n          zod.refine((val) => typeof val !== 'undefined', {\n            error,\n            abort: true,\n          }),\n          zod.overwrite(encode),\n        ),\n        type,\n      ),\n      // @ts-expect-error\n      decodedZodType: zod.pipe(\n        type,\n        // @ts-expect-error\n        zod\n          .custom()\n          .check(\n            zod.refine((val) => typeof val !== 'undefined', {\n              error,\n              abort: true,\n            }),\n            zod.overwrite(decode),\n          ),\n      ),\n      params: { encode },\n    })\n  }\n}\n\nexport const custom = CustomType.factory\n"],"version":3,"file":"custom.js"}

package/dist/types/date.js

@@ -1,13 +1,14 @@
-import { iso, union } from "@zod/mini";
+import * as zod from "zod/v4-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.datetime(), iso.date()])
+			type: zod.union([zod.iso.datetime(), zod.iso.date()])
 		});
 	}
 }
+export const date = DateType.factory;
 
 //# sourceMappingURL=date.js.map

package/dist/types/date.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,KAAK,aAAgC,WAAW;AACzD,SAAS,YAAY,qBAAqB,aAAa;AAEvD,OAAO,MAAM,iBAAiB,cAG5B;CACA,OAAO,UAAU;AACf,SAAO,WAAW,QAGhB;GACA,QAAQ,CAACA,UAAwB,IAAI,KAAK;GAC1C,QAAQ,CAACC,UAAwB,MAAM,aAAa;GACpD,MAAM,MAAM,CAAC,IAAI,UAAU,EAAE,IAAI,MAAM,AAAC,EAAC;EAC1C,EAAC;CACH;AACF","names":["value: string","value: Date"],"sources":["../../src/types/date.ts"],"sourcesContent":["import { iso, union, type ZodMiniUnion } from '@zod/mini'\nimport { CustomType, TransformType } from './custom.ts'\n\nexport class DateType extends TransformType<\n  Date,\n  ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>\n> {\n  static factory() {\n    return CustomType.factory<\n      Date,\n      ZodMiniUnion<Array<iso.ZodMiniISODate | iso.ZodMiniISODateTime>>\n    >({\n      decode: (value: string): Date => new Date(value),\n      encode: (value: Date): string => value.toISOString(),\n      type: union([iso.datetime(), iso.date()]),\n    })\n  }\n}\n"],"version":3,"file":"date.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,YAAY,qBAAqB,aAAa;AAEvD,OAAO,MAAM,iBAAiB,cAG5B;CACA,OAAO,UAAU;AACf,SAAO,WAAW,QAKhB;GACA,QAAQ,CAACA,UAAwB,IAAI,KAAK;GAC1C,QAAQ,CAACC,UAAwB,MAAM,aAAa;GACpD,MAAM,IAAI,MAAM,CAAC,IAAI,IAAI,UAAU,EAAE,IAAI,IAAI,MAAM,AAAC,EAAC;EACtD,EAAC;CACH;AACF;AAED,OAAO,MAAM,OAAO,SAAS","names":["value: string","value: Date"],"sources":["../../src/types/date.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { CustomType, TransformType } from './custom.ts'\n\nexport class DateType extends TransformType<\n  Date,\n  zod.ZodMiniUnion<[zod.iso.ZodMiniISODate, zod.iso.ZodMiniISODateTime]>\n> {\n  static factory() {\n    return CustomType.factory<\n      Date,\n      zod.ZodMiniUnion<\n        Array<zod.iso.ZodMiniISODate | zod.iso.ZodMiniISODateTime>\n      >\n    >({\n      decode: (value: string): Date => new Date(value),\n      encode: (value: Date): string => value.toISOString(),\n      type: zod.union([zod.iso.datetime(), zod.iso.date()]),\n    })\n  }\n}\n\nexport const date = DateType.factory\n"],"version":3,"file":"date.js"}

package/dist/types/enum.js

@@ -1,12 +1,14 @@
-import { enum as enum_ } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 export class EnumType extends BaseType {
 	static factory(values) {
 		return new EnumType({
-			encodedZodType: enum_(values),
+			encodedZodType: zod.enum(values),
 			props: { values }
 		});
 	}
 }
+const _enum = EnumType.factory;
+export { _enum as enum };
 
 //# sourceMappingURL=enum.js.map

package/dist/types/enum.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAoB,QAAQ,aAA+B,WAAW;AACtE,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,iBAEH,SAAwD;CAKhE,OAAO,QAAiDA,QAAW;AACjE,SAAO,IAAI,SAAS;GAClB,gBAAgB,MAAM,OAAc;GACpC,OAAO,EAAE,OAAQ;EAClB;CACF;AACF","names":["values: T"],"sources":["../../src/types/enum.ts"],"sourcesContent":["import { type core, enum as enum_, type ZodMiniEnum } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class EnumType<\n  T extends core.util.EnumLike = core.util.EnumLike,\n> extends BaseType<ZodMiniEnum<T>, ZodMiniEnum<T>, { values: T }> {\n  static factory<T extends core.util.EnumLike>(values: T): EnumType<T>\n  static factory<T extends string[]>(\n    values: T,\n  ): EnumType<core.util.ToEnum<T[number]>>\n  static factory<T extends core.util.EnumLike | string[]>(values: T) {\n    return new EnumType({\n      encodedZodType: enum_(values as any),\n      props: { values },\n    })\n  }\n}\n"],"version":3,"file":"enum.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,iBAEH,SAAgE;CAKxE,OAAO,QAAqDA,QAAW;AACrE,SAAO,IAAI,SAAS;GAClB,gBAAgB,IAAI,KAAK,OAAc;GACvC,OAAO,EAAE,OAAQ;EAClB;CACF;AACF;AAED,MAAM,QAAQ,SAAS;AAEvB,SAAS,SAAS","names":["values: T"],"sources":["../../src/types/enum.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType } from './base.ts'\n\nexport class EnumType<\n  T extends zod.core.util.EnumLike = zod.core.util.EnumLike,\n> extends BaseType<zod.ZodMiniEnum<T>, zod.ZodMiniEnum<T>, { values: T }> {\n  static factory<T extends zod.core.util.EnumLike>(values: T): EnumType<T>\n  static factory<T extends string[]>(\n    values: T,\n  ): EnumType<zod.core.util.ToEnum<T[number]>>\n  static factory<T extends zod.core.util.EnumLike | string[]>(values: T) {\n    return new EnumType({\n      encodedZodType: zod.enum(values as any),\n      props: { values },\n    })\n  }\n}\n\nconst _enum = EnumType.factory\n\nexport { _enum as enum }\n"],"version":3,"file":"enum.js"}

package/dist/types/literal.js

@@ -1,12 +1,13 @@
-import { literal } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 export class LiteralType extends BaseType {
 	static factory(value) {
 		return new LiteralType({
-			encodedZodType: literal(value),
+			encodedZodType: zod.literal(value),
 			props: { value }
 		});
 	}
 }
+export const literal = LiteralType.factory;
 
 //# sourceMappingURL=literal.js.map

package/dist/types/literal.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,eAAoC,WAAW;AACxD,SAAS,gBAAyC,WAAW;AAE7D,OAAO,MAAM,oBAEH,SAA6D;CACrE,OAAO,QAAsCA,OAAU;AACrD,SAAO,IAAI,YAAe;GACxB,gBAAgB,QAAQ,MAAM;GAC9B,OAAO,EAAE,MAAO;EACjB;CACF;AACF","names":["value: T"],"sources":["../../src/types/literal.ts"],"sourcesContent":["import { literal, type ZodMiniLiteral } from '@zod/mini'\nimport { BaseType, type PrimitiveValueType } from './base.ts'\n\nexport class LiteralType<\n  T extends PrimitiveValueType = PrimitiveValueType,\n> extends BaseType<ZodMiniLiteral<T>, ZodMiniLiteral<T>, { value: T }> {\n  static factory<T extends PrimitiveValueType>(value: T) {\n    return new LiteralType<T>({\n      encodedZodType: literal(value),\n      props: { value },\n    })\n  }\n}\n"],"version":3,"file":"literal.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAyC,WAAW;AAE7D,OAAO,MAAM,oBAEH,SAAqE;CAC7E,OAAO,QAAsCA,OAAU;AACrD,SAAO,IAAI,YAAe;GACxB,gBAAgB,IAAI,QAAQ,MAAM;GAClC,OAAO,EAAE,MAAO;EACjB;CACF;AACF;AAED,OAAO,MAAM,UAAU,YAAY","names":["value: T"],"sources":["../../src/types/literal.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType, type PrimitiveValueType } from './base.ts'\n\nexport class LiteralType<\n  T extends PrimitiveValueType = PrimitiveValueType,\n> extends BaseType<zod.ZodMiniLiteral<T>, zod.ZodMiniLiteral<T>, { value: T }> {\n  static factory<T extends PrimitiveValueType>(value: T) {\n    return new LiteralType<T>({\n      encodedZodType: zod.literal(value),\n      props: { value },\n    })\n  }\n}\n\nexport const literal = LiteralType.factory\n"],"version":3,"file":"literal.js"}

package/dist/types/never.js

@@ -1,9 +1,10 @@
-import { never } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 export class NeverType extends BaseType {
 	static factory() {
-		return new NeverType({ encodedZodType: never() });
+		return new NeverType({ encodedZodType: zod.never() });
 	}
 }
+export const never = NeverType.factory;
 
 //# sourceMappingURL=never.js.map

package/dist/types/never.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,aAAgC,WAAW;AACpD,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,kBAAkB,SAAuB;CACpD,OAAO,UAAU;AACf,SAAO,IAAI,UAAU,EACnB,gBAAgB,OAAO,CACxB;CACF;AACF","names":[],"sources":["../../src/types/never.ts"],"sourcesContent":["import { never, type ZodMiniNever } from '@zod/mini'\nimport { BaseType } from './base.ts'\n\nexport class NeverType extends BaseType<ZodMiniNever> {\n  static factory() {\n    return new NeverType({\n      encodedZodType: never(),\n    })\n  }\n}\n"],"version":3,"file":"never.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAgB,WAAW;AAEpC,OAAO,MAAM,kBAAkB,SAA2B;CACxD,OAAO,UAAU;AACf,SAAO,IAAI,UAAU,EACnB,gBAAgB,IAAI,OAAO,CAC5B;CACF;AACF;AAED,OAAO,MAAM,QAAQ,UAAU","names":[],"sources":["../../src/types/never.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType } from './base.ts'\n\nexport class NeverType extends BaseType<zod.ZodMiniNever> {\n  static factory() {\n    return new NeverType({\n      encodedZodType: zod.never(),\n    })\n  }\n}\n\nexport const never = NeverType.factory\n"],"version":3,"file":"never.js"}

package/dist/types/number.js

@@ -1,35 +1,35 @@
-import { gt, gte, int, lt, lte, number, regex, string } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 import { CustomType, TransformType } from "./custom.js";
 export class NumberType extends BaseType {
 	static factory(...checks) {
 		return new NumberType({
-			encodedZodType: number().check(...checks),
+			encodedZodType: zod.number().check(...checks),
 			params: { checks }
 		});
 	}
 	positive() {
-		return NumberType.factory(...this.params.checks, gte(0));
+		return NumberType.factory(...this.params.checks, zod.gte(0));
 	}
 	negative() {
-		return NumberType.factory(...this.params.checks, lte(0));
+		return NumberType.factory(...this.params.checks, zod.lte(0));
 	}
 	lt(value) {
-		return NumberType.factory(...this.params.checks, lt(value));
+		return NumberType.factory(...this.params.checks, zod.lt(value));
 	}
 	lte(value) {
-		return NumberType.factory(...this.params.checks, lte(value));
+		return NumberType.factory(...this.params.checks, zod.lte(value));
 	}
 	gte(value) {
-		return NumberType.factory(...this.params.checks, gte(value));
+		return NumberType.factory(...this.params.checks, zod.gte(value));
 	}
 	gt(value) {
-		return NumberType.factory(...this.params.checks, gt(value));
+		return NumberType.factory(...this.params.checks, zod.gt(value));
 	}
 }
 export class IntegerType extends NumberType {
 	static factory(...checks) {
-		return NumberType.factory(...checks, int());
+		return NumberType.factory(...checks, zod.int());
 	}
 }
 export class BigIntType extends TransformType {
@@ -37,10 +37,13 @@ export class BigIntType extends TransformType {
 		return CustomType.factory({
 			decode: (value) => BigInt(value),
 			encode: (value) => value.toString(),
-			type: string().check(regex(/^-?\d+$/)),
+			type: zod.string().check(zod.regex(/^-?\d+$/)),
 			error: "Invalid bigint format"
 		});
 	}
 }
+export const number = NumberType.factory;
+export const integer = IntegerType.factory;
+export const bigInt = BigIntType.factory;
 
 //# sourceMappingURL=number.js.map

package/dist/types/number.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAEE,IACA,KACA,KACA,IACA,KACA,QACA,OACA,cAGK,WAAW;AAClB,SAAS,gBAAgB,WAAW;AACpC,SAAS,YAAY,qBAAqB,aAAa;AAIvD,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,WAAW;AACT,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,EAAE,CAAC;CACzD;CAED,WAAW;AACT,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,EAAE,CAAC;CACzD;CAED,GAAGA,OAAe;AAChB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,GAAG,MAAM,CAAC;CAC5D;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,MAAM,CAAC;CAC7D;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,MAAM,CAAC;CAC7D;CAED,GAAGA,OAAe;AAChB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,GAAG,MAAM,CAAC;CAC5D;AACF;AAED,OAAO,MAAM,oBAAoB,WAAW;CAC1C,OAAO,QAAQ,GAAG,QAAiB;AACjC,SAAO,WAAW,QAAQ,GAAG,QAAQ,KAAK,CAAC;CAC5C;AACF;AAED,OAAO,MAAM,mBAAmB,cAA6C;CAC3E,OAAO,UAAU;AACf,SAAO,WAAW,QAAuC;GACvD,QAAQ,CAAC,UAAU,OAAO,MAAM;GAChC,QAAQ,CAAC,UAAU,MAAM,UAAU;GACnC,MAAM,QAAQ,CAAC,MAAM,MAAM,UAAU,CAAC;GACtC,OAAO;EACR,EAAC;CACH;AACF","names":["value: number"],"sources":["../../src/types/number.ts"],"sourcesContent":["import {\n  type core,\n  gt,\n  gte,\n  int,\n  lt,\n  lte,\n  number,\n  regex,\n  string,\n  type ZodMiniNumber,\n  type ZodMiniString,\n} from '@zod/mini'\nimport { BaseType } from './base.ts'\nimport { CustomType, TransformType } from './custom.ts'\n\ntype Check = core.CheckFn<number> | core.$ZodCheck<number>\n\nexport class NumberType extends BaseType<\n  ZodMiniNumber<number>,\n  ZodMiniNumber<number>\n> {\n  static factory(...checks: Check[]) {\n    return new NumberType({\n      encodedZodType: number().check(...checks),\n      params: { checks },\n    })\n  }\n\n  positive() {\n    return NumberType.factory(...this.params.checks, gte(0))\n  }\n\n  negative() {\n    return NumberType.factory(...this.params.checks, lte(0))\n  }\n\n  lt(value: number) {\n    return NumberType.factory(...this.params.checks, lt(value))\n  }\n\n  lte(value: number) {\n    return NumberType.factory(...this.params.checks, lte(value))\n  }\n\n  gte(value: number) {\n    return NumberType.factory(...this.params.checks, gte(value))\n  }\n\n  gt(value: number) {\n    return NumberType.factory(...this.params.checks, gt(value))\n  }\n}\n\nexport class IntegerType extends NumberType {\n  static factory(...checks: Check[]) {\n    return NumberType.factory(...checks, int())\n  }\n}\n\nexport class BigIntType extends TransformType<bigint, ZodMiniString<string>> {\n  static factory() {\n    return CustomType.factory<bigint, ZodMiniString<string>>({\n      decode: (value) => BigInt(value),\n      encode: (value) => value.toString(),\n      type: string().check(regex(/^-?\\d+$/)),\n      error: 'Invalid bigint format',\n    })\n  }\n}\n"],"version":3,"file":"number.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAClC,SAAS,gBAAgB,WAAW;AACpC,SAAS,YAAY,qBAAqB,aAAa;AAIvD,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,WAAW;AACT,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,IAAI,EAAE,CAAC;CAC7D;CAED,WAAW;AACT,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,IAAI,EAAE,CAAC;CAC7D;CAED,GAAGA,OAAe;AAChB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,GAAG,MAAM,CAAC;CAChE;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,IAAI,MAAM,CAAC;CACjE;CAED,IAAIA,OAAe;AACjB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,IAAI,MAAM,CAAC;CACjE;CAED,GAAGA,OAAe;AAChB,SAAO,WAAW,QAAQ,GAAG,KAAK,OAAO,QAAQ,IAAI,GAAG,MAAM,CAAC;CAChE;AACF;AAED,OAAO,MAAM,oBAAoB,WAAW;CAC1C,OAAO,QAAQ,GAAG,QAAiB;AACjC,SAAO,WAAW,QAAQ,GAAG,QAAQ,IAAI,KAAK,CAAC;CAChD;AACF;AAED,OAAO,MAAM,mBAAmB,cAG9B;CACA,OAAO,UAAU;AACf,SAAO,WAAW,QAA2C;GAC3D,QAAQ,CAAC,UAAU,OAAO,MAAM;GAChC,QAAQ,CAAC,UAAU,MAAM,UAAU;GACnC,MAAM,IAAI,QAAQ,CAAC,MAAM,IAAI,MAAM,UAAU,CAAC;GAC9C,OAAO;EACR,EAAC;CACH;AACF;AAED,OAAO,MAAM,SAAS,WAAW;AACjC,OAAO,MAAM,UAAU,YAAY;AACnC,OAAO,MAAM,SAAS,WAAW","names":["value: number"],"sources":["../../src/types/number.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\nimport { BaseType } from './base.ts'\nimport { CustomType, TransformType } from './custom.ts'\n\ntype Check = zod.core.CheckFn<number> | zod.core.$ZodCheck<number>\n\nexport class NumberType extends BaseType<\n  zod.ZodMiniNumber<number>,\n  zod.ZodMiniNumber<number>\n> {\n  static factory(...checks: Check[]) {\n    return new NumberType({\n      encodedZodType: zod.number().check(...checks),\n      params: { checks },\n    })\n  }\n\n  positive() {\n    return NumberType.factory(...this.params.checks, zod.gte(0))\n  }\n\n  negative() {\n    return NumberType.factory(...this.params.checks, zod.lte(0))\n  }\n\n  lt(value: number) {\n    return NumberType.factory(...this.params.checks, zod.lt(value))\n  }\n\n  lte(value: number) {\n    return NumberType.factory(...this.params.checks, zod.lte(value))\n  }\n\n  gte(value: number) {\n    return NumberType.factory(...this.params.checks, zod.gte(value))\n  }\n\n  gt(value: number) {\n    return NumberType.factory(...this.params.checks, zod.gt(value))\n  }\n}\n\nexport class IntegerType extends NumberType {\n  static factory(...checks: Check[]) {\n    return NumberType.factory(...checks, zod.int())\n  }\n}\n\nexport class BigIntType extends TransformType<\n  bigint,\n  zod.ZodMiniString<string>\n> {\n  static factory() {\n    return CustomType.factory<bigint, zod.ZodMiniString<string>>({\n      decode: (value) => BigInt(value),\n      encode: (value) => value.toString(),\n      type: zod.string().check(zod.regex(/^-?\\d+$/)),\n      error: 'Invalid bigint format',\n    })\n  }\n}\n\nexport const number = NumberType.factory\nexport const integer = IntegerType.factory\nexport const bigInt = BigIntType.factory\n"],"version":3,"file":"number.js"}

package/dist/types/object.js

@@ -1,4 +1,4 @@
-import { object, record, strictObject } from "@zod/mini";
+import * as zod from "zod/v4-mini";
 import { BaseType } from "./base.js";
 import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
@@ -10,8 +10,8 @@ export class ObjectType extends BaseType {
 			decodeProperties[key] = properties[key].decodedZodType;
 		}
 		return new ObjectType({
-			encodedZodType: object(encodeProperties),
-			decodedZodType: object(decodeProperties),
+			encodedZodType: zod.object(encodeProperties),
+			decodedZodType: zod.object(decodeProperties),
 			props: { properties }
 		});
 	}
@@ -19,8 +19,8 @@ export class ObjectType extends BaseType {
 export class RecordType extends BaseType {
 	static factory(key, element) {
 		return new RecordType({
-			encodedZodType: record(key.encodedZodType, element.encodedZodType),
-			decodedZodType: record(key.decodedZodType, element.decodedZodType),
+			encodedZodType: zod.record(key.encodedZodType, element.encodedZodType),
+			decodedZodType: zod.record(key.decodedZodType, element.decodedZodType),
 			props: {
 				key,
 				element
@@ -58,5 +58,7 @@ export function partial(object) {
 	}
 	return ObjectType.factory(properties);
 }
+export const object = ObjectType.factory;
+export const record = RecordType.factory;
 
 //# sourceMappingURL=object.js.map

package/dist/types/object.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAEE,QACA,QACA,oBAGK,WAAW;AAElB,SAAS,gBAAqD,WAAW;AACzE,SAAS,gBAAgB,WAAW;AAMpC,OAAO,MAAM,mBAAmD,SAI9D;CACA,OAAO,QAAwCA,YAAe;EAC5D,MAAM,mBAAmB,CAAE;EAG3B,MAAM,mBAAmB,CAAE;AAI3B,OAAK,MAAM,OAAO,YAAY;AAC5B,oBAAiB,OAAO,WAAW,KAAK;AACxC,oBAAiB,OAAO,WAAW,KAAK;EACzC;AAED,SAAO,IAAI,WAAc;GACvB,gBAAgB,OAAO,iBAAiB;GACxC,gBAAgB,OAAO,iBAAiB;GACxC,OAAO,EAAE,WAAY;EACtB;CACF;AACF;AAED,OAAO,MAAM,mBAGH,SAGR;CACA,OAAO,QAGLC,KAAQC,SAAY;AACpB,SAAO,IAAI,WAAiB;GAC1B,gBAAgB,OACb,IAAY,gBACb,QAAQ,eACT;GACD,gBAAgB,OACb,IAAY,gBACb,QAAQ,eACT;GACD,OAAO;IAAE;IAAK;GAAS;EACxB;CACF;AACF;AAED,OAAO,SAAS,MACdC,MAC6E;AAC7E,QAAO,SAAS,QAAQ,OAAO,KAAK,KAAK,MAAM,WAAW,CAAQ;AACnE;AAED,OAAO,SAAS,KAIdC,QACAC,MAOC;CACD,MAAM,aAAa,OAAO,YACxB,OAAO,QAAQ,OAAO,MAAM,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,KAAK,KAAK,CACrE;AACD,QAAO,WAAW,QAAQ,WAAW;AACtC;AAED,OAAO,SAAS,KAIdD,QACAE,MAKC;CACD,MAAM,aAAa,OAAO,YACxB,OAAO,QAAQ,OAAO,MAAM,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,MAAM,KAAK,KAAK,CACtE;AACD,QAAO,WAAW,QAAQ,WAAW;AACtC;AAED,OAAO,SAAS,OACdC,SACAC,YAOC;AACD,QAAO,WAAW,QAAQ;EACxB,GAAG,QAAQ,MAAM;EACjB,GAAG;CACJ,EAAC;AACH;AAED,OAAO,SAAS,MACdC,SACAC,SASC;AACD,QAAO,WAAW,QAAQ;EACxB,GAAG,QAAQ,MAAM;EACjB,GAAG,QAAQ,MAAM;CAClB,EAAC;AACH;AAED,OAAO,SAAS,QAIdC,QAGC;CACD,MAAM,aAAa,CAAE;AAErB,MAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,OAAO,MAAM,WAAW,EAAE;AAClE,aAAW,OAAO,MAAM,UAAU;CACnC;AAED,QAAO,WAAW,QAAQ,WAAW;AACtC","names":["properties: T","key: K","element: E","type: T","source: T","pick: P","omit: P","object1: T","properties: P","object1: T1","object2: T2","object: T"],"sources":["../../src/types/object.ts"],"sourcesContent":["import {\n  type core,\n  object,\n  record,\n  strictObject,\n  type ZodMiniObject,\n  type ZodMiniRecord,\n} from '@zod/mini'\n\nimport { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'\nimport { EnumType } from './enum.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { StringType } from './string.ts'\n\nexport type ObjectTypeProps = { [k: string]: BaseTypeAny }\nexport type AnyObjectType = ObjectType<ObjectTypeProps>\nexport class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<\n  ZodMiniObject<{ [K in keyof T]: T[K]['encodedZodType'] }, {}>,\n  ZodMiniObject<{ [K in keyof T]: T[K]['decodedZodType'] }, {}>,\n  { properties: T }\n> {\n  static factory<T extends ObjectTypeProps = {}>(properties: T) {\n    const encodeProperties = {} as {\n      [K in keyof T]: T[K]['encodedZodType']\n    }\n    const decodeProperties = {} as {\n      [K in keyof T]: T[K]['decodedZodType']\n    }\n\n    for (const key in properties) {\n      encodeProperties[key] = properties[key].encodedZodType\n      decodeProperties[key] = properties[key].decodedZodType\n    }\n\n    return new ObjectType<T>({\n      encodedZodType: object(encodeProperties),\n      decodedZodType: object(decodeProperties),\n      props: { properties },\n    })\n  }\n}\n\nexport class RecordType<\n  K extends LiteralType<string | number> | EnumType | StringType,\n  E extends BaseType,\n> extends BaseType<\n  ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,\n  ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>\n> {\n  static factory<\n    K extends LiteralType<string | number> | EnumType | StringType,\n    E extends BaseType,\n  >(key: K, element: E) {\n    return new RecordType<K, E>({\n      encodedZodType: record(\n        (key as any).encodedZodType,\n        element.encodedZodType,\n      ),\n      decodedZodType: record(\n        (key as any).decodedZodType,\n        element.decodedZodType,\n      ),\n      props: { key, element },\n    })\n  }\n}\n\nexport function keyof<T extends ObjectType>(\n  type: T,\n): EnumType<core.util.ToEnum<Extract<keyof T['props']['properties'], string>>> {\n  return EnumType.factory(Object.keys(type.props.properties) as any)\n}\n\nexport function pick<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  pick: P,\n): ObjectType<{\n  [K in keyof P]: P[K] extends true\n    ? K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n    : never\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => pick[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function omit<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  omit: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] as K extends keyof P\n    ? never\n    : K]: T['props']['properties'][K]\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => !omit[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function extend<T extends AnyObjectType, P extends ObjectTypeProps>(\n  object1: T,\n  properties: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P\n    ? P[K]\n    : K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...properties,\n  }) as any\n}\n\nexport function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(\n  object1: T1,\n  object2: T2,\n): ObjectType<{\n  [K in\n    | keyof T1['props']['properties']\n    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']\n    ? T2['props']['properties'][K]\n    : K extends keyof T1['props']['properties']\n      ? T1['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...object2.props.properties,\n  }) as any\n}\n\nexport function partial<\n  T extends AnyObjectType,\n  P extends T extends ObjectType<infer Props> ? Props : never,\n>(\n  object: T,\n): ObjectType<{\n  [K in keyof P]: OptionalType<P[K]>\n}> {\n  const properties = {} as any\n\n  for (const [key, value] of Object.entries(object.props.properties)) {\n    properties[key] = value.optional()\n  }\n\n  return ObjectType.factory(properties)\n}\n"],"version":3,"file":"object.js"}
+{"mappings":"AAAA,YAAY,SAAS,aAAa;AAElC,SAAS,gBAAqD,WAAW;AACzE,SAAS,gBAAgB,WAAW;AAMpC,OAAO,MAAM,mBAAmD,SAU9D;CACA,OAAO,QAAwCA,YAAe;EAC5D,MAAM,mBAAmB,CAAE;EAG3B,MAAM,mBAAmB,CAAE;AAI3B,OAAK,MAAM,OAAO,YAAY;AAC5B,oBAAiB,OAAO,WAAW,KAAK;AACxC,oBAAiB,OAAO,WAAW,KAAK;EACzC;AAED,SAAO,IAAI,WAAc;GACvB,gBAAgB,IAAI,OAAO,iBAAiB;GAC5C,gBAAgB,IAAI,OAAO,iBAAiB;GAC5C,OAAO,EAAE,WAAY;EACtB;CACF;AACF;AAED,OAAO,MAAM,mBAGH,SAGR;CACA,OAAO,QAGLC,KAAQC,SAAY;AACpB,SAAO,IAAI,WAAiB;GAC1B,gBAAgB,IAAI,OACjB,IAAY,gBACb,QAAQ,eACT;GACD,gBAAgB,IAAI,OACjB,IAAY,gBACb,QAAQ,eACT;GACD,OAAO;IAAE;IAAK;GAAS;EACxB;CACF;AACF;AAED,OAAO,SAAS,MACdC,MAGA;AACA,QAAO,SAAS,QAAQ,OAAO,KAAK,KAAK,MAAM,WAAW,CAAQ;AACnE;AAED,OAAO,SAAS,KAIdC,QACAC,MAOC;CACD,MAAM,aAAa,OAAO,YACxB,OAAO,QAAQ,OAAO,MAAM,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,KAAK,KAAK,KAAK,CACrE;AACD,QAAO,WAAW,QAAQ,WAAW;AACtC;AAED,OAAO,SAAS,KAIdD,QACAE,MAKC;CACD,MAAM,aAAa,OAAO,YACxB,OAAO,QAAQ,OAAO,MAAM,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,MAAM,KAAK,KAAK,CACtE;AACD,QAAO,WAAW,QAAQ,WAAW;AACtC;AAED,OAAO,SAAS,OACdC,SACAC,YAOC;AACD,QAAO,WAAW,QAAQ;EACxB,GAAG,QAAQ,MAAM;EACjB,GAAG;CACJ,EAAC;AACH;AAED,OAAO,SAAS,MACdC,SACAC,SASC;AACD,QAAO,WAAW,QAAQ;EACxB,GAAG,QAAQ,MAAM;EACjB,GAAG,QAAQ,MAAM;CAClB,EAAC;AACH;AAED,OAAO,SAAS,QAIdC,QAGC;CACD,MAAM,aAAa,CAAE;AAErB,MAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,OAAO,MAAM,WAAW,EAAE;AAClE,aAAW,OAAO,MAAM,UAAU;CACnC;AAED,QAAO,WAAW,QAAQ,WAAW;AACtC;AAED,OAAO,MAAM,SAAS,WAAW;AACjC,OAAO,MAAM,SAAS,WAAW","names":["properties: T","key: K","element: E","type: T","source: T","pick: P","omit: P","object1: T","properties: P","object1: T1","object2: T2","object: T"],"sources":["../../src/types/object.ts"],"sourcesContent":["import * as zod from 'zod/v4-mini'\n\nimport { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'\nimport { EnumType } from './enum.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { StringType } from './string.ts'\n\nexport type ObjectTypeProps = { [k: string]: BaseTypeAny }\nexport type AnyObjectType = ObjectType<ObjectTypeProps>\nexport class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<\n  zod.ZodMiniObject<\n    { [K in keyof T]: T[K]['encodedZodType'] },\n    zod.core.$strict\n  >,\n  zod.ZodMiniObject<\n    { [K in keyof T]: T[K]['decodedZodType'] },\n    zod.core.$strict\n  >,\n  { properties: T }\n> {\n  static factory<T extends ObjectTypeProps = {}>(properties: T) {\n    const encodeProperties = {} as {\n      [K in keyof T]: T[K]['encodedZodType']\n    }\n    const decodeProperties = {} as {\n      [K in keyof T]: T[K]['decodedZodType']\n    }\n\n    for (const key in properties) {\n      encodeProperties[key] = properties[key].encodedZodType\n      decodeProperties[key] = properties[key].decodedZodType\n    }\n\n    return new ObjectType<T>({\n      encodedZodType: zod.object(encodeProperties),\n      decodedZodType: zod.object(decodeProperties),\n      props: { properties },\n    })\n  }\n}\n\nexport class RecordType<\n  K extends LiteralType<string | number> | EnumType | StringType,\n  E extends BaseType,\n> extends BaseType<\n  zod.ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,\n  zod.ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>\n> {\n  static factory<\n    K extends LiteralType<string | number> | EnumType | StringType,\n    E extends BaseType,\n  >(key: K, element: E) {\n    return new RecordType<K, E>({\n      encodedZodType: zod.record(\n        (key as any).encodedZodType,\n        element.encodedZodType,\n      ),\n      decodedZodType: zod.record(\n        (key as any).decodedZodType,\n        element.decodedZodType,\n      ),\n      props: { key, element },\n    })\n  }\n}\n\nexport function keyof<T extends ObjectType>(\n  type: T,\n): EnumType<\n  zod.core.util.ToEnum<Extract<keyof T['props']['properties'], string>>\n> {\n  return EnumType.factory(Object.keys(type.props.properties) as any)\n}\n\nexport function pick<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  pick: P,\n): ObjectType<{\n  [K in keyof P]: P[K] extends true\n    ? K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n    : never\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => pick[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function omit<\n  T extends AnyObjectType,\n  P extends { [K in keyof T['props']['properties']]?: true },\n>(\n  source: T,\n  omit: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] as K extends keyof P\n    ? never\n    : K]: T['props']['properties'][K]\n}> {\n  const properties = Object.fromEntries(\n    Object.entries(source.props.properties).filter(([key]) => !omit[key]),\n  )\n  return ObjectType.factory(properties) as any\n}\n\nexport function extend<T extends AnyObjectType, P extends ObjectTypeProps>(\n  object1: T,\n  properties: P,\n): ObjectType<{\n  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P\n    ? P[K]\n    : K extends keyof T['props']['properties']\n      ? T['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...properties,\n  }) as any\n}\n\nexport function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(\n  object1: T1,\n  object2: T2,\n): ObjectType<{\n  [K in\n    | keyof T1['props']['properties']\n    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']\n    ? T2['props']['properties'][K]\n    : K extends keyof T1['props']['properties']\n      ? T1['props']['properties'][K]\n      : never\n}> {\n  return ObjectType.factory({\n    ...object1.props.properties,\n    ...object2.props.properties,\n  }) as any\n}\n\nexport function partial<\n  T extends AnyObjectType,\n  P extends T extends ObjectType<infer Props> ? Props : never,\n>(\n  object: T,\n): ObjectType<{\n  [K in keyof P]: OptionalType<P[K]>\n}> {\n  const properties = {} as any\n\n  for (const [key, value] of Object.entries(object.props.properties)) {\n    properties[key] = value.optional()\n  }\n\n  return ObjectType.factory(properties)\n}\n\nexport const object = ObjectType.factory\nexport const record = RecordType.factory\n"],"version":3,"file":"object.js"}