@nmtjs/type 0.10.2 → 0.10.4

package/src/types/temporal.ts

@@ -1,5 +1,5 @@
-import { iso, regex, string, type ZodMiniString } from '@zod/mini'
 import { Temporal } from 'temporal-polyfill'
+import { iso, regex, string, type ZodMiniString } from 'zod/v4-mini'
 import { CustomType, TransformType } from './custom.ts'
 
 type Types = Exclude<
@@ -144,3 +144,11 @@ 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

package/src/types/tuple.ts

@@ -1,5 +1,5 @@
 import type { ArrayMap } from '@nmtjs/common'
-import { tuple, type ZodMiniTuple } from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType } from './base.ts'
 
 export class TupleType<
@@ -10,11 +10,11 @@ export class TupleType<
   R extends BaseType | null = BaseType | null,
 > extends BaseType<
   R extends BaseType
-    ? ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, R['encodedZodType']>
-    : ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, null>,
+    ? zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, R['encodedZodType']>
+    : zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, null>,
   R extends BaseType
-    ? ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, R['decodedZodType']>
-    : ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, null>,
+    ? zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, R['decodedZodType']>
+    : zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, null>,
   { elements: T; rest?: R }
 > {
   static factory<
@@ -25,10 +25,12 @@ export class TupleType<
     const decoded = elements.map((el) => el.decodedZodType)
     return new TupleType<T, R>({
       // @ts-expect-error
-      encodedZodType: tuple(encoded, rest?.encodedZodType),
+      encodedZodType: zod.tuple(encoded, rest?.encodedZodType),
       // @ts-expect-error
-      decodedZodType: tuple(decoded, rest?.decodedZodType),
+      decodedZodType: zod.tuple(decoded, rest?.decodedZodType),
       props: { elements, rest },
     })
   }
 }
+
+export const tuple = TupleType.factory

package/src/types/type.ts

@@ -0,0 +1,31 @@
+import type { BaseTypeAny } from './base.ts'
+
+export * from './any.ts'
+export * from './array.ts'
+export * from './boolean.ts'
+export * from './custom.ts'
+export * from './date.ts'
+export * from './enum.ts'
+export * from './literal.ts'
+export * from './never.ts'
+export * from './number.ts'
+export * from './object.ts'
+export * from './string.ts'
+export * from './tuple.ts'
+export * from './union.ts'
+
+export 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']
+  }
+}

package/src/types/union.ts

@@ -1,13 +1,5 @@
 import type { ArrayMap } from '@nmtjs/common'
-import {
-  type core,
-  discriminatedUnion,
-  intersection,
-  union,
-  type ZodMiniDiscriminatedUnion,
-  type ZodMiniIntersection,
-  type ZodMiniUnion,
-} from '@zod/mini'
+import * as zod from 'zod/v4-mini'
 import { BaseType, type BaseTypeAny } from './base.ts'
 import type { LiteralType } from './literal.ts'
 import type { ObjectType, ObjectTypeProps } from './object.ts'
@@ -18,8 +10,8 @@ export class UnionType<
     ...BaseType[],
   ],
 > extends BaseType<
-  ZodMiniUnion<ArrayMap<T, 'encodedZodType'>>,
-  ZodMiniUnion<ArrayMap<T, 'decodedZodType'>>,
+  zod.ZodMiniUnion<ArrayMap<T, 'encodedZodType'>>,
+  zod.ZodMiniUnion<ArrayMap<T, 'decodedZodType'>>,
   { options: T }
 > {
   static factory<
@@ -37,8 +29,8 @@ export class UnionType<
       'decodedZodType'
     >
     return new UnionType<T>({
-      encodedZodType: union(encoded),
-      decodedZodType: union(decoded),
+      encodedZodType: zod.union(encoded),
+      decodedZodType: zod.union(decoded),
       props: { options },
     })
   }
@@ -47,8 +39,8 @@ export class UnionType<
 export class IntersactionType<
   T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],
 > extends BaseType<
-  ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>,
-  ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>,
+  zod.ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>,
+  zod.ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>,
   { options: T }
 > {
   static factory<
@@ -56,8 +48,14 @@ export class IntersactionType<
   >(...options: T) {
     const [first, second] = options
     return new IntersactionType<T>({
-      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 },
     })
   }
@@ -78,8 +76,8 @@ export class DiscriminatedUnionType<
   T extends
     readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],
 > extends BaseType<
-  ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodedZodType'>>,
-  ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodedZodType'>>,
+  zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodedZodType'>>,
+  zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodedZodType'>>,
   {
     key: K
     options: T
@@ -100,10 +98,16 @@ export class DiscriminatedUnionType<
     >
     return new DiscriminatedUnionType<K, T>({
       // @ts-expect-error
-      encodedZodType: discriminatedUnion(encoded),
+      encodedZodType: zod.discriminatedUnion(key, encoded),
       // @ts-expect-error
-      decodedZodType: discriminatedUnion(decoded),
+      decodedZodType: zod.discriminatedUnion(key, decoded),
       props: { key, options },
     })
   }
 }
+
+export const union = UnionType.factory
+export const or = UnionType.factory
+export const intersection = IntersactionType.factory
+export const and = IntersactionType.factory
+export const discriminatedUnion = DiscriminatedUnionType.factory