@nmtjs/type 0.12.6 → 0.12.8

package/package.json

@@ -16,20 +16,19 @@
   "peerDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^3.25.0",
-    "@nmtjs/common": "0.12.6"
+    "@nmtjs/common": "0.12.8"
   },
   "devDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^3.25.0",
-    "@nmtjs/common": "0.12.6"
+    "@nmtjs/common": "0.12.8"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.6",
+  "version": "0.12.8",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/src/index.ts

@@ -1,8 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import * as type from './types/type.ts'
-
-zod.config(zod.core.locales.en())
-
-export * from './types/base.ts'
-export { type, type as t }
-export default type

package/src/temporal.ts

@@ -1 +0,0 @@
-export * from './types/temporal.ts'

package/src/types/any.ts

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

package/src/types/array.ts

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

package/src/types/base.ts

@@ -1,183 +0,0 @@
-import * as zod from 'zod/v4-mini'
-
-export type PrimitiveValueType = string | number | boolean | null
-
-export type PrimitiveZodType =
-  | zod.ZodMiniNever
-  | zod.ZodMiniDefault
-  | zod.ZodMiniNullable
-  | zod.ZodMiniOptional
-  | zod.ZodMiniString
-  | zod.ZodMiniObject
-  | zod.ZodMiniAny
-  | zod.ZodMiniArray
-  | zod.ZodMiniBoolean
-  | zod.ZodMiniNumber
-  | zod.ZodMiniEnum<any>
-  | zod.ZodMiniLiteral<PrimitiveValueType>
-  | zod.ZodMiniUnion
-  | zod.ZodMiniIntersection
-  | zod.ZodMiniRecord
-
-export type SimpleZodType = zod.ZodMiniType
-
-export type ZodType = SimpleZodType | zod.ZodMiniType
-
-export type TypeProps = Record<string, any>
-
-export type TypeMetadata<T = any> = {
-  id?: string
-  description?: string
-  examples?: T[]
-  title?: string
-}
-
-export type TypeParams = {
-  encode?: (value: any) => any
-  metadata?: TypeMetadata
-  checks: Array<zod.core.CheckFn<any> | zod.core.$ZodCheck<any>>
-}
-
-export type DefaultTypeParams = {
-  encode?: TypeParams['encode']
-  metadata?: TypeMetadata
-}
-
-export type BaseTypeAny<
-  EncodedZodType extends SimpleZodType = SimpleZodType,
-  DecodedZodType extends ZodType = zod.ZodMiniType,
-> = BaseType<EncodedZodType, DecodedZodType, TypeProps>
-
-export const typesRegistry = zod.registry<TypeMetadata>()
-
-export const NeemataTypeError = zod.core.$ZodError
-export type NeemataTypeError = zod.core.$ZodError
-
-export abstract class BaseType<
-  EncodedZodType extends SimpleZodType = SimpleZodType,
-  DecodedZodType extends ZodType = EncodedZodType,
-  Props extends TypeProps = TypeProps,
-> {
-  readonly encodedZodType: EncodedZodType
-  readonly decodedZodType: DecodedZodType
-  readonly props: Props
-  readonly params: TypeParams
-
-  constructor({
-    encodedZodType,
-    decodedZodType = encodedZodType as unknown as DecodedZodType,
-    props = {} as Props,
-    params = {} as Partial<TypeParams>,
-  }: {
-    encodedZodType: EncodedZodType
-    decodedZodType?: DecodedZodType
-    props?: Props
-    params?: Partial<TypeParams>
-  }) {
-    this.encodedZodType = encodedZodType
-    this.decodedZodType = decodedZodType
-
-    this.props = props
-    this.params = Object.assign({ checks: [] }, params)
-  }
-
-  optional(): OptionalType<this> {
-    return OptionalType.factory(this)
-  }
-
-  nullable(): NullableType<this> {
-    return NullableType.factory(this)
-  }
-
-  nullish() {
-    return this.nullable().optional()
-  }
-
-  default(value: this['encodedZodType']['_zod']['input']): DefaultType<this> {
-    return DefaultType.factory(this, value)
-  }
-
-  title(title: string): this {
-    return this.meta({ title })
-  }
-
-  description(description: string): this {
-    return this.meta({ description })
-  }
-
-  examples(...examples: this['encodedZodType']['_zod']['input'][]): this {
-    return this.meta({
-      examples: this.params.encode
-        ? examples.map(this.params.encode)
-        : examples,
-    })
-  }
-
-  meta(newMetadata: TypeMetadata): this {
-    const metadata = typesRegistry.get(this.encodedZodType) ?? {}
-    Object.assign(metadata, newMetadata)
-    typesRegistry.add(this.encodedZodType, metadata)
-    return this
-  }
-
-  encode(
-    data: this['encodedZodType']['_zod']['input'],
-  ): this['encodedZodType']['_zod']['output'] {
-    return this.encodedZodType.parse(data, { reportInput: true })
-  }
-
-  decode(
-    data: this['decodedZodType']['_zod']['input'],
-  ): this['decodedZodType']['_zod']['output'] {
-    return this.decodedZodType.parse(data, { reportInput: true })
-  }
-}
-
-export class OptionalType<
-  Type extends BaseTypeAny = BaseTypeAny,
-> extends BaseType<
-  zod.ZodMiniOptional<Type['encodedZodType']>,
-  zod.ZodMiniOptional<Type['decodedZodType']>,
-  { inner: Type }
-> {
-  static factory<T extends BaseTypeAny>(type: T) {
-    return new OptionalType<T>({
-      encodedZodType: zod.optional(type.encodedZodType) as any,
-      props: { inner: type },
-    })
-  }
-}
-
-export class NullableType<
-  Type extends BaseTypeAny<any> = BaseTypeAny<any>,
-> extends BaseType<
-  zod.ZodMiniNullable<Type['encodedZodType']>,
-  zod.ZodMiniNullable<Type['decodedZodType']>,
-  { inner: Type }
-> {
-  static factory<T extends BaseTypeAny<any>>(type: T) {
-    return new NullableType<T>({
-      encodedZodType: zod.nullable(type.encodedZodType),
-      props: { inner: type },
-    })
-  }
-}
-
-export class DefaultType<
-  Type extends BaseTypeAny = BaseTypeAny,
-> extends BaseType<
-  zod.ZodMiniDefault<Type['encodedZodType']>,
-  zod.ZodMiniDefault<Type['decodedZodType']>,
-  { inner: Type }
-> {
-  static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {
-    return new DefaultType<T>({
-      encodedZodType: zod._default(
-        type.encodedZodType,
-        type.params.encode?.(defaultValue) ?? defaultValue,
-      ) as any,
-      decodedZodType: zod._default(type.decodedZodType, defaultValue) as any,
-      props: { inner: type },
-    })
-  }
-}

package/src/types/boolean.ts

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

package/src/types/custom.ts

@@ -1,79 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { BaseType, type SimpleZodType, type ZodType } from './base.ts'
-
-export type CustomTransformFn<I, O> = (value: I) => O
-export abstract class TransformType<
-  Type,
-  EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,
-  DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,
-> extends BaseType<
-  zod.ZodMiniPipe<
-    zod.ZodMiniType<
-      DecodedType['_zod']['output'],
-      DecodedType['_zod']['input']
-    >,
-    EncodedType
-  >,
-  zod.ZodMiniPipe<
-    EncodedType,
-    zod.ZodMiniType<DecodedType['_zod']['output'], DecodedType['_zod']['input']>
-  >
-> {}
-
-export class CustomType<
-  Type,
-  EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,
-  DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,
-> extends TransformType<Type, EncodedType, DecodedType> {
-  static factory<
-    Type,
-    EncodedType extends SimpleZodType = zod.ZodMiniType<Type, Type>,
-    DecodedType extends ZodType = zod.ZodMiniType<Type, Type>,
-  >({
-    decode,
-    encode,
-    error,
-    type = zod.any() as unknown as EncodedType,
-  }: {
-    decode: CustomTransformFn<
-      EncodedType['_zod']['input'],
-      DecodedType['_zod']['output']
-    >
-    encode: CustomTransformFn<
-      DecodedType['_zod']['input'],
-      EncodedType['_zod']['output']
-    >
-    error?: string | zod.core.$ZodErrorMap<zod.core.$ZodIssueBase>
-    type?: EncodedType
-  }) {
-    return new CustomType<Type, EncodedType, DecodedType>({
-      encodedZodType: zod.pipe(
-        zod.custom().check(
-          zod.refine((val) => typeof val !== 'undefined', {
-            error,
-            abort: true,
-          }),
-          zod.overwrite(encode),
-        ),
-        type,
-      ),
-      // @ts-expect-error
-      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

package/src/types/date.ts

@@ -1,20 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { CustomType, TransformType } from './custom.ts'
-
-export class DateType extends TransformType<
-  Date,
-  zod.ZodMiniUnion<[zod.iso.ZodMiniISODate, zod.iso.ZodMiniISODateTime]>
-> {
-  static factory() {
-    return CustomType.factory<
-      Date,
-      zod.ZodMiniUnion<[zod.iso.ZodMiniISODate, zod.iso.ZodMiniISODateTime]>
-    >({
-      decode: (value: string): Date => new Date(value),
-      encode: (value: Date): string => value.toISOString(),
-      type: zod.union([zod.iso.date(), zod.iso.datetime()]),
-    })
-  }
-}
-
-export const date = DateType.factory

package/src/types/enum.ts

@@ -1,21 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { BaseType } from './base.ts'
-
-export class EnumType<
-  T extends zod.core.util.EnumLike = zod.core.util.EnumLike,
-> extends BaseType<zod.ZodMiniEnum<T>, zod.ZodMiniEnum<T>, { values: T }> {
-  static factory<T extends zod.core.util.EnumLike>(values: T): EnumType<T>
-  static factory<T extends string[]>(
-    values: T,
-  ): EnumType<zod.core.util.ToEnum<T[number]>>
-  static factory<T extends zod.core.util.EnumLike | string[]>(values: T) {
-    return new EnumType({
-      encodedZodType: zod.enum(values as any),
-      props: { values },
-    })
-  }
-}
-
-const _enum = EnumType.factory
-
-export { _enum as enum }

package/src/types/literal.ts

@@ -1,15 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { BaseType, type PrimitiveValueType } from './base.ts'
-
-export class LiteralType<
-  T extends PrimitiveValueType = PrimitiveValueType,
-> extends BaseType<zod.ZodMiniLiteral<T>, zod.ZodMiniLiteral<T>, { value: T }> {
-  static factory<T extends PrimitiveValueType>(value: T) {
-    return new LiteralType<T>({
-      encodedZodType: zod.literal(value),
-      props: { value },
-    })
-  }
-}
-
-export const literal = LiteralType.factory

package/src/types/never.ts

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

package/src/types/number.ts

@@ -1,65 +0,0 @@
-import * as zod from 'zod/v4-mini'
-import { BaseType } from './base.ts'
-import { CustomType, TransformType } from './custom.ts'
-
-type Check = zod.core.CheckFn<number> | zod.core.$ZodCheck<number>
-
-export class NumberType extends BaseType<
-  zod.ZodMiniNumber<number>,
-  zod.ZodMiniNumber<number>
-> {
-  static factory(...checks: Check[]) {
-    return new NumberType({
-      encodedZodType: zod.number().check(...checks),
-      params: { checks },
-    })
-  }
-
-  positive() {
-    return NumberType.factory(...this.params.checks, zod.gte(0))
-  }
-
-  negative() {
-    return NumberType.factory(...this.params.checks, zod.lte(0))
-  }
-
-  lt(value: number) {
-    return NumberType.factory(...this.params.checks, zod.lt(value))
-  }
-
-  lte(value: number) {
-    return NumberType.factory(...this.params.checks, zod.lte(value))
-  }
-
-  gte(value: number) {
-    return NumberType.factory(...this.params.checks, zod.gte(value))
-  }
-
-  gt(value: number) {
-    return NumberType.factory(...this.params.checks, zod.gt(value))
-  }
-}
-
-export class IntegerType extends NumberType {
-  static factory(...checks: Check[]) {
-    return NumberType.factory(...checks, zod.int())
-  }
-}
-
-export class BigIntType extends TransformType<
-  bigint,
-  zod.ZodMiniString<string>
-> {
-  static factory() {
-    return CustomType.factory<bigint, zod.ZodMiniString<string>>({
-      decode: (value) => BigInt(value),
-      encode: (value) => value.toString(),
-      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

package/src/types/object.ts

@@ -1,163 +0,0 @@
-import * as zod from 'zod/v4-mini'
-
-import { BaseType, type BaseTypeAny, type OptionalType } from './base.ts'
-import { EnumType } from './enum.ts'
-import type { LiteralType } from './literal.ts'
-import type { StringType } from './string.ts'
-
-export type ObjectTypeProps = { [k: string]: BaseTypeAny }
-export type AnyObjectType = ObjectType<ObjectTypeProps>
-export class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<
-  zod.ZodMiniObject<
-    { [K in keyof T]: T[K]['encodedZodType'] },
-    zod.core.$strict
-  >,
-  zod.ZodMiniObject<
-    { [K in keyof T]: T[K]['decodedZodType'] },
-    zod.core.$strict
-  >,
-  { properties: T }
-> {
-  static factory<T extends ObjectTypeProps = {}>(properties: T) {
-    const encodeProperties = {} as {
-      [K in keyof T]: T[K]['encodedZodType']
-    }
-    const decodeProperties = {} as {
-      [K in keyof T]: T[K]['decodedZodType']
-    }
-
-    for (const key in properties) {
-      encodeProperties[key] = properties[key].encodedZodType
-      decodeProperties[key] = properties[key].decodedZodType
-    }
-
-    return new ObjectType<T>({
-      encodedZodType: zod.object(encodeProperties),
-      decodedZodType: zod.object(decodeProperties),
-      props: { properties },
-    })
-  }
-}
-
-export class RecordType<
-  K extends LiteralType<string | number> | EnumType | StringType,
-  E extends BaseType,
-> extends BaseType<
-  zod.ZodMiniRecord<K['encodedZodType'], E['encodedZodType']>,
-  zod.ZodMiniRecord<K['decodedZodType'], E['decodedZodType']>
-> {
-  static factory<
-    K extends LiteralType<string | number> | EnumType | StringType,
-    E extends BaseType,
-  >(key: K, element: E) {
-    return new RecordType<K, E>({
-      encodedZodType: zod.record(
-        (key as any).encodedZodType,
-        element.encodedZodType,
-      ),
-      decodedZodType: zod.record(
-        (key as any).decodedZodType,
-        element.decodedZodType,
-      ),
-      props: { key, element },
-    })
-  }
-}
-
-export function keyof<T extends ObjectType>(
-  type: T,
-): EnumType<
-  zod.core.util.ToEnum<Extract<keyof T['props']['properties'], string>>
-> {
-  return EnumType.factory(Object.keys(type.props.properties) as any)
-}
-
-export function pick<
-  T extends AnyObjectType,
-  P extends { [K in keyof T['props']['properties']]?: true },
->(
-  source: T,
-  pick: P,
-): ObjectType<{
-  [K in keyof P]: P[K] extends true
-    ? K extends keyof T['props']['properties']
-      ? T['props']['properties'][K]
-      : never
-    : never
-}> {
-  const properties = Object.fromEntries(
-    Object.entries(source.props.properties).filter(([key]) => pick[key]),
-  )
-  return ObjectType.factory(properties) as any
-}
-
-export function omit<
-  T extends AnyObjectType,
-  P extends { [K in keyof T['props']['properties']]?: true },
->(
-  source: T,
-  omit: P,
-): ObjectType<{
-  [K in keyof T['props']['properties'] as K extends keyof P
-    ? never
-    : K]: T['props']['properties'][K]
-}> {
-  const properties = Object.fromEntries(
-    Object.entries(source.props.properties).filter(([key]) => !omit[key]),
-  )
-  return ObjectType.factory(properties) as any
-}
-
-export function extend<T extends AnyObjectType, P extends ObjectTypeProps>(
-  object1: T,
-  properties: P,
-): ObjectType<{
-  [K in keyof T['props']['properties'] | keyof P]: K extends keyof P
-    ? P[K]
-    : K extends keyof T['props']['properties']
-      ? T['props']['properties'][K]
-      : never
-}> {
-  return ObjectType.factory({
-    ...object1.props.properties,
-    ...properties,
-  }) as any
-}
-
-export function merge<T1 extends AnyObjectType, T2 extends AnyObjectType>(
-  object1: T1,
-  object2: T2,
-): ObjectType<{
-  [K in
-    | keyof T1['props']['properties']
-    | keyof T2['props']['properties']]: K extends keyof T2['props']['properties']
-    ? T2['props']['properties'][K]
-    : K extends keyof T1['props']['properties']
-      ? T1['props']['properties'][K]
-      : never
-}> {
-  return ObjectType.factory({
-    ...object1.props.properties,
-    ...object2.props.properties,
-  }) as any
-}
-
-export function partial<
-  T extends AnyObjectType,
-  P extends T extends ObjectType<infer Props> ? Props : never,
->(
-  object: T,
-): ObjectType<{
-  [K in keyof P]: OptionalType<P[K]>
-}> {
-  const properties = {} as any
-
-  for (const [key, value] of Object.entries(object.props.properties)) {
-    properties[key] = value.optional()
-  }
-
-  return ObjectType.factory(properties)
-}
-
-export const object = ObjectType.factory
-export const record = RecordType.factory

package/src/types/string.ts

@@ -1,78 +0,0 @@
-import * as zod from 'zod/v4-mini'
-
-import { BaseType } from './base.ts'
-
-type Check = zod.core.CheckFn<string> | zod.core.$ZodCheck<string>
-
-export class StringType extends BaseType<
-  zod.ZodMiniString<string>,
-  zod.ZodMiniString<string>
-> {
-  static factory(...checks: Check[]) {
-    return new StringType({
-      encodedZodType: zod.string().check(...checks),
-      params: { checks },
-    })
-  }
-
-  max(value: number) {
-    return StringType.factory(...this.params.checks, zod.maxLength(value))
-  }
-
-  min(value: number) {
-    return StringType.factory(...this.params.checks, zod.minLength(value))
-  }
-
-  pattern(pattern: string | RegExp) {
-    return StringType.factory(
-      ...this.params.checks,
-      zod.regex(typeof pattern === 'string' ? new RegExp(pattern) : pattern),
-    )
-  }
-
-  email(options?: zod.core.$ZodEmailParams) {
-    return StringType.factory(...this.params.checks, zod.email(options))
-  }
-
-  url(options?: zod.core.$ZodURLParams) {
-    return StringType.factory(...this.params.checks, zod.url(options))
-  }
-
-  ipv4(options?: zod.core.$ZodIPv4Params) {
-    return StringType.factory(...this.params.checks, zod.ipv4(options))
-  }
-
-  ipv6(options?: zod.core.$ZodIPv6Params) {
-    return StringType.factory(...this.params.checks, zod.ipv6(options))
-  }
-
-  uuid(options?: zod.core.$ZodUUIDParams) {
-    return StringType.factory(...this.params.checks, zod.uuid(options))
-  }
-
-  emoji(options?: zod.core.$ZodEmojiParams) {
-    return StringType.factory(...this.params.checks, zod.emoji(options))
-  }
-
-  nanoid(options?: zod.core.$ZodNanoIDParams) {
-    return StringType.factory(...this.params.checks, zod.nanoid(options))
-  }
-
-  cuid(options?: zod.core.$ZodCUIDParams) {
-    return StringType.factory(...this.params.checks, zod.cuid(options))
-  }
-
-  cuid2(options?: zod.core.$ZodCUID2Params) {
-    return StringType.factory(...this.params.checks, zod.cuid2(options))
-  }
-
-  e164(options?: zod.core.$ZodE164Params) {
-    return StringType.factory(...this.params.checks, zod.e164(options))
-  }
-
-  jwt(options?: zod.core.$ZodJWTParams) {
-    return StringType.factory(...this.params.checks, zod.jwt(options))
-  }
-}
-
-export const string = StringType.factory

package/src/types/temporal.ts

@@ -1,154 +0,0 @@
-import { Temporal } from 'temporal-polyfill'
-import { iso, regex, string, type ZodMiniString } from 'zod/v4-mini'
-import { CustomType, TransformType } from './custom.ts'
-
-type Types = Exclude<
-  keyof typeof Temporal,
-  'Now' | 'Instant' | 'Calendar' | 'TimeZone'
->
-
-type TemporalTransformer<T extends Types> = {
-  decode: (value: string) => ReturnType<(typeof Temporal)[T]['from']>
-  encode: (value: ReturnType<(typeof Temporal)[T]['from']>) => string
-}
-
-const createTemporalTransformer = <T extends Types>(
-  type: T,
-  decode = (value: string) => Temporal[type].from(value),
-) => {
-  const encode = (value: ReturnType<(typeof Temporal)[T]['from']>) =>
-    value.toString({
-      calendarName: 'never',
-      smallestUnit: 'microsecond',
-      timeZoneName: 'never',
-    })
-
-  return {
-    decode,
-    encode,
-  } as TemporalTransformer<T>
-}
-
-type EncodedType = ZodMiniString<string>
-
-export class PlainDateType extends TransformType<
-  Temporal.PlainDate,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainDate')
-
-  static factory() {
-    return CustomType.factory<Temporal.PlainDate, EncodedType>({
-      decode: PlainDateType.transformer.decode,
-      encode: PlainDateType.transformer.encode,
-      type: iso.date(),
-      error: 'Invalid date format',
-    })
-  }
-}
-
-export class PlainDateTimeType extends TransformType<
-  Temporal.PlainDateTime,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainDateTime')
-
-  static factory() {
-    return CustomType.factory<Temporal.PlainDateTime, EncodedType>({
-      decode: PlainDateTimeType.transformer.decode,
-      encode: PlainDateTimeType.transformer.encode,
-      type: iso.datetime({ local: true }),
-      error: 'Invalid datetime format',
-    })
-  }
-}
-
-export class ZonedDateTimeType extends TransformType<
-  Temporal.ZonedDateTime,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('ZonedDateTime', (value) =>
-    Temporal.Instant.from(value).toZonedDateTimeISO('UTC'),
-  )
-
-  static factory() {
-    return CustomType.factory<Temporal.ZonedDateTime, EncodedType>({
-      decode: ZonedDateTimeType.transformer.decode,
-      encode: ZonedDateTimeType.transformer.encode,
-      type: iso.datetime({ local: true }),
-      error: 'Invalid datetime format',
-    })
-  }
-}
-
-export class PlainTimeType extends TransformType<
-  Temporal.PlainTime,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainTime')
-
-  static factory() {
-    return CustomType.factory<Temporal.PlainTime, EncodedType>({
-      decode: PlainTimeType.transformer.decode,
-      encode: PlainTimeType.transformer.encode,
-      type: iso.time(),
-      error: 'Invalid time format',
-    })
-  }
-}
-
-export class DurationType extends TransformType<
-  Temporal.Duration,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('Duration')
-
-  static factory() {
-    return CustomType.factory<Temporal.Duration, EncodedType>({
-      decode: DurationType.transformer.decode,
-      encode: DurationType.transformer.encode,
-      type: iso.duration(),
-      error: 'Invalid duration format',
-    })
-  }
-}
-
-export class PlainYearMonthType extends TransformType<
-  Temporal.PlainYearMonth,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainYearMonth')
-
-  static factory() {
-    return CustomType.factory<Temporal.PlainYearMonth, EncodedType>({
-      decode: PlainYearMonthType.transformer.decode,
-      encode: PlainYearMonthType.transformer.encode,
-      type: string().check(regex(/^\d{4}-\d{2}$/)),
-      error: 'Invalid year-month format',
-    })
-  }
-}
-
-export class PlainMonthDayType extends TransformType<
-  Temporal.PlainMonthDay,
-  EncodedType
-> {
-  static transformer = createTemporalTransformer('PlainMonthDay')
-
-  static factory() {
-    return CustomType.factory<Temporal.PlainMonthDay, EncodedType>({
-      decode: PlainMonthDayType.transformer.decode,
-      encode: PlainMonthDayType.transformer.encode,
-      type: string().check(regex(/^\d{2}-\d{2}$/)),
-      error: 'Invalid month-day format',
-    })
-  }
-}
-
-export const plainDate = PlainDateType.factory
-export const plainDatetime = PlainDateTimeType.factory
-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,36 +0,0 @@
-import type { ArrayMap } from '@nmtjs/common'
-import * as zod from 'zod/v4-mini'
-import { BaseType } from './base.ts'
-
-export class TupleType<
-  T extends readonly [BaseType, ...BaseType[]] = readonly [
-    BaseType,
-    ...BaseType[],
-  ],
-  R extends BaseType | null = BaseType | null,
-> extends BaseType<
-  R extends BaseType
-    ? zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, R['encodedZodType']>
-    : zod.ZodMiniTuple<ArrayMap<T, 'encodedZodType'>, null>,
-  R extends BaseType
-    ? zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, R['decodedZodType']>
-    : zod.ZodMiniTuple<ArrayMap<T, 'decodedZodType'>, null>,
-  { elements: T; rest?: R }
-> {
-  static factory<
-    T extends readonly [BaseType, ...BaseType[]],
-    R extends BaseType | null = null,
-  >(elements: T, rest: R = null as R) {
-    const encoded = elements.map((el) => el.encodedZodType)
-    const decoded = elements.map((el) => el.decodedZodType)
-    return new TupleType<T, R>({
-      // @ts-expect-error
-      encodedZodType: zod.tuple(encoded, rest?.encodedZodType),
-      // @ts-expect-error
-      decodedZodType: zod.tuple(decoded, rest?.decodedZodType),
-      props: { elements, rest },
-    })
-  }
-}
-
-export const tuple = TupleType.factory

package/src/types/type.ts

@@ -1,31 +0,0 @@
-import type { BaseTypeAny } from './base.ts'
-
-export * from './any.ts'
-export * from './array.ts'
-export * from './boolean.ts'
-export * from './custom.ts'
-export * from './date.ts'
-export * from './enum.ts'
-export * from './literal.ts'
-export * from './never.ts'
-export * from './number.ts'
-export * from './object.ts'
-export * from './string.ts'
-export * from './tuple.ts'
-export * from './union.ts'
-
-export 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,113 +0,0 @@
-import type { ArrayMap } from '@nmtjs/common'
-import * as zod from 'zod/v4-mini'
-import { BaseType, type BaseTypeAny } from './base.ts'
-import type { LiteralType } from './literal.ts'
-import type { ObjectType, ObjectTypeProps } from './object.ts'
-
-export class UnionType<
-  T extends readonly [BaseType, ...BaseType[]] = readonly [
-    BaseType,
-    ...BaseType[],
-  ],
-> extends BaseType<
-  zod.ZodMiniUnion<ArrayMap<T, 'encodedZodType'>>,
-  zod.ZodMiniUnion<ArrayMap<T, 'decodedZodType'>>,
-  { options: T }
-> {
-  static factory<
-    T extends readonly [BaseType, ...BaseType[]] = readonly [
-      BaseType,
-      ...BaseType[],
-    ],
-  >(...options: T) {
-    const encoded = options.map((t) => t.encodedZodType) as ArrayMap<
-      T,
-      'encodedZodType'
-    >
-    const decoded = options.map((t) => t.decodedZodType) as ArrayMap<
-      T,
-      'decodedZodType'
-    >
-    return new UnionType<T>({
-      encodedZodType: zod.union(encoded),
-      decodedZodType: zod.union(decoded),
-      props: { options },
-    })
-  }
-}
-
-export class IntersactionType<
-  T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],
-> extends BaseType<
-  zod.ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>,
-  zod.ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>,
-  { options: T }
-> {
-  static factory<
-    T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],
-  >(...options: T) {
-    const [first, second] = options
-    return new IntersactionType<T>({
-      encodedZodType: zod.intersection(
-        first.encodedZodType,
-        second.encodedZodType,
-      ),
-      decodedZodType: zod.intersection(
-        first.decodedZodType,
-        second.decodedZodType,
-      ),
-      props: { options },
-    })
-  }
-}
-
-export type DiscriminatedUnionProperties<K extends string = string> = {
-  [OK in K]: LiteralType<string>
-} & {
-  [OK in string]: any
-}
-
-export type DiscriminatedUnionOptionType<K extends string> = ObjectType<
-  ObjectTypeProps & { [_ in K]: BaseTypeAny }
->
-
-export class DiscriminatedUnionType<
-  K extends string = string,
-  T extends
-    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],
-> extends BaseType<
-  zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodedZodType'>>,
-  zod.ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodedZodType'>>,
-  {
-    key: K
-    options: T
-  }
-> {
-  static factory<
-    K extends string = string,
-    T extends
-      readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],
-  >(key: K, ...options: T) {
-    const encoded = options.map((t) => t.encodedZodType) as ArrayMap<
-      T,
-      'encodedZodType'
-    >
-    const decoded = options.map((t) => t.decodedZodType) as ArrayMap<
-      T,
-      'decodedZodType'
-    >
-    return new DiscriminatedUnionType<K, T>({
-      // @ts-expect-error
-      encodedZodType: zod.discriminatedUnion(key, encoded),
-      // @ts-expect-error
-      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