@nmtjs/type 0.6.5 → 0.7.1

package/dist/types/union.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/union.ts"],"sourcesContent":["import {\n  type TIntersect,\n  type TObject,\n  type TSchema,\n  type TUnion,\n  Type,\n  type UnionToTuple,\n} from '@sinclair/typebox'\nimport type { StaticInputDecode } from '../inference.ts'\nimport {\n  DiscriminatedUnion,\n  type DiscriminatedUnionProperties,\n  type TDiscriminatedUnion,\n} from '../schemas/discriminated-union.ts'\nimport { BaseType, type BaseTypeAny } from './base.ts'\nimport type { ObjectType, ObjectTypeProps } from './object.ts'\n\nexport class UnionType<\n  T extends readonly BaseType[] = readonly BaseType[],\n  S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n> extends BaseType<TUnion<S>, { options: T }, StaticInputDecode<TUnion<S>>> {\n  static factory<\n    T extends readonly BaseType[] = readonly BaseType[],\n    S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n  >(...options: T) {\n    return new UnionType<T, S>(\n      Type.Union(options.map((t) => t.schema)) as any,\n      {\n        options,\n      },\n    )\n  }\n}\n\nexport class IntersactionType<\n  T extends readonly BaseType[] = readonly BaseType[],\n  S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n> extends BaseType<\n  TIntersect<S>,\n  { options: T },\n  StaticInputDecode<TIntersect<S>>\n> {\n  static factory<\n    T extends readonly BaseType[] = readonly BaseType[],\n    S extends TSchema[] = UnionToTuple<T[number]['schema']>,\n  >(...options: T) {\n    return new IntersactionType<T, S>(\n      Type.Intersect(options.map((t) => t.schema)) as any,\n      { options },\n    )\n  }\n}\n\nexport type DiscriminatedUnionOptionType<K extends string> = ObjectType<\n  ObjectTypeProps & { [_ in K]: BaseTypeAny }\n>\n\nexport class DiscriminatedUnionType<\n  K extends string = string,\n  T extends\n    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n  S extends TObject<DiscriminatedUnionProperties<K>>[] = [],\n> extends BaseType<\n  TDiscriminatedUnion<K, S>,\n  {\n    key: K\n    options: T\n  },\n  StaticInputDecode<TDiscriminatedUnion<K, S>>\n> {\n  static factory<\n    K extends string,\n    T extends readonly DiscriminatedUnionOptionType<K>[],\n    //@ts-expect-error\n    S extends TObject<DiscriminatedUnionProperties<K>>[] = UnionToTuple<\n      T[number]['schema']\n    >,\n  >(key: K, ...options: T) {\n    return new DiscriminatedUnionType<K, T, S>(\n      DiscriminatedUnion(key, options.map((t) => t.schema) as any),\n      { key, options },\n    )\n  }\n}\n"],"names":["Type","DiscriminatedUnion","BaseType","UnionType","factory","options","Union","map","t","schema","IntersactionType","Intersect","DiscriminatedUnionType","key"],"mappings":"AAAA,SAKEA,IAAI,QAEC,oBAAmB;AAE1B,SACEC,kBAAkB,QAGb,oCAAmC;AAC1C,SAASC,QAAQ,QAA0B,YAAW;AAGtD,OAAO,MAAMC,kBAGHD;IACR,OAAOE,QAGL,GAAGC,OAAU,EAAE;QACf,OAAO,IAAIF,UACTH,KAAKM,KAAK,CAACD,QAAQE,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM,IACtC;YACEJ;QACF;IAEJ;AACF;AAEA,OAAO,MAAMK,yBAGHR;IAKR,OAAOE,QAGL,GAAGC,OAAU,EAAE;QACf,OAAO,IAAIK,iBACTV,KAAKW,SAAS,CAACN,QAAQE,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM,IAC1C;YAAEJ;QAAQ;IAEd;AACF;AAMA,OAAO,MAAMO,+BAKHV;IAQR,OAAOE,QAOLS,GAAM,EAAE,GAAGR,OAAU,EAAE;QACvB,OAAO,IAAIO,uBACTX,mBAAmBY,KAAKR,QAAQE,GAAG,CAAC,CAACC,IAAMA,EAAEC,MAAM,IACnD;YAAEI;YAAKR;QAAQ;IAEnB;AACF"}
+{"mappings":"AAAA,SAEE,oBACA,cACA,aAIK,WAAW;AAClB,SAAS,gBAAkC,WAAW;AAItD,OAAO,MAAM,kBAEH,SAIR;CACA,OAAO,QACL,GAAG,SACH;AACA,SAAO,IAAI,UAAa;GACtB,gBAAgB,MAAM,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe,CAAC;GAC3D,gBAAgB,MAAM,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe,CAAC;GAC3D,OAAO,EAAE,QAAS;EACnB;CACF;AACF;AAED,OAAO,MAAM,yBAEH,SAIR;CACA,OAAO,QAEL,GAAG,SAAY;EACf,MAAM,CAAC,OAAO,OAAO,GAAG;AACxB,SAAO,IAAI,iBAAoB;GAC7B,gBAAgB,aAAa,MAAM,gBAAgB,OAAO,eAAe;GACzE,gBAAgB,aAAa,MAAM,gBAAgB,OAAO,eAAe;GACzE,OAAO,EAAE,QAAS;EACnB;CACF;AACF;AAYD,OAAO,MAAM,+BAIH,SAOR;CACA,OAAO,QAILA,KAAQ,GAAG,SAAY;AACvB,SAAO,IAAI,uBAA6B;GACtC,gBAAgB,mBACd,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe,CACrC;GACD,gBAAgB,mBACd,QAAQ,IAAI,CAAC,MAAM,EAAE,eAAe,CACrC;GACD,OAAO;IAAE;IAAK;GAAS;EACxB;CACF;AACF","names":["key: K"],"sources":["src/types/union.ts"],"sourcesContent":["import {\n  type core,\n  discriminatedUnion,\n  intersection,\n  union,\n  type ZodMiniDiscriminatedUnion,\n  type ZodMiniIntersection,\n  type ZodMiniUnion,\n} from '@zod/mini'\nimport { BaseType, type BaseTypeAny } from './base.ts'\nimport type { LiteralType } from './literal.ts'\nimport type { ObjectType, ObjectTypeProps } from './object.ts'\n\nexport class UnionType<\n  T extends readonly BaseType[] = readonly BaseType[],\n> extends BaseType<\n  ZodMiniUnion<core.utils.Flatten<T[number]['encodedZodType'][]>>,\n  ZodMiniUnion<core.utils.Flatten<T[number]['decodedZodType'][]>>,\n  { options: T }\n> {\n  static factory<T extends readonly BaseType[] = readonly BaseType[]>(\n    ...options: T\n  ) {\n    return new UnionType<T>({\n      encodedZodType: union(options.map((t) => t.encodedZodType)),\n      decodedZodType: union(options.map((t) => t.decodedZodType)),\n      props: { options },\n    })\n  }\n}\n\nexport class IntersactionType<\n  T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],\n> extends BaseType<\n  ZodMiniIntersection<T[0]['encodedZodType'], T[1]['encodedZodType']>,\n  ZodMiniIntersection<T[0]['decodedZodType'], T[1]['decodedZodType']>,\n  { options: T }\n> {\n  static factory<\n    T extends readonly [BaseType, BaseType] = readonly [BaseType, BaseType],\n  >(...options: T) {\n    const [first, second] = options\n    return new IntersactionType<T>({\n      encodedZodType: intersection(first.encodedZodType, second.encodedZodType),\n      decodedZodType: intersection(first.decodedZodType, second.decodedZodType),\n      props: { options },\n    })\n  }\n}\n\nexport type DiscriminatedUnionProperties<K extends string = string> = {\n  [OK in K]: LiteralType<string>\n} & {\n  [OK in string]: any\n}\n\nexport type DiscriminatedUnionOptionType<K extends string> = ObjectType<\n  ObjectTypeProps & { [_ in K]: BaseTypeAny }\n>\n\nexport class DiscriminatedUnionType<\n  K extends string = string,\n  T extends\n    readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n> extends BaseType<\n  ZodMiniDiscriminatedUnion<core.utils.Flatten<T[number]['encodedZodType'][]>>,\n  ZodMiniDiscriminatedUnion<core.utils.Flatten<T[number]['decodedZodType'][]>>,\n  {\n    key: K\n    options: T\n  }\n> {\n  static factory<\n    K extends string = string,\n    T extends\n      readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[],\n  >(key: K, ...options: T) {\n    return new DiscriminatedUnionType<K, T>({\n      encodedZodType: discriminatedUnion(\n        options.map((t) => t.encodedZodType) as any,\n      ),\n      decodedZodType: discriminatedUnion(\n        options.map((t) => t.decodedZodType) as any,\n      ),\n      props: { key, options },\n    })\n  }\n}\n"],"version":3}

package/package.json

@@ -3,30 +3,18 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
-      "default": "./dist/index.js",
+      "import": "./dist/index.js",
       "types": "./src/index.ts"
     },
-    "./compiler": {
-      "bun": "./src/compiler.ts",
-      "default": "./dist/compiler.js",
-      "types": "./src/compiler.ts"
-    },
-    "./runtime": {
-      "bun": "./src/runtime.ts",
-      "default": "./dist/runtime.js",
-      "types": "./src/runtime.ts"
-    },
     "./temporal": {
-      "bun": "./src/temporal.ts",
-      "default": "./dist/temporal.js",
+      "import": "./dist/temporal.js",
       "types": "./src/temporal.ts"
     }
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.13",
-    "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.6.5"
+    "@zod/mini": "4.0.0-beta.0",
+    "temporal-polyfill": "^0.3.0",
+    "@nmtjs/common": "0.7.1"
   },
   "files": [
     "src",
@@ -34,9 +22,9 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.6.5",
+  "version": "0.7.1",
   "scripts": {
-    "build": "neemata-build -p neutral --root=./src './**/*.ts'",
+    "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"
   }
 }

package/src/index.ts

@@ -1,16 +1,11 @@
-import type {
-  StaticInputDecode,
-  StaticInputEncode,
-  StaticOutputDecode,
-  StaticOutputEncode,
-} from './inference.ts'
+import * as zod from '@zod/mini'
 import { AnyType } from './types/any.ts'
 import { ArrayType } from './types/array.ts'
 import type { BaseTypeAny } from './types/base.ts'
 import { BooleanType } from './types/boolean.ts'
 import { CustomType } from './types/custom.ts'
 import { DateType } from './types/date.ts'
-import { EnumType, ObjectEnumType } from './types/enum.ts'
+import { EnumType } from './types/enum.ts'
 import { LiteralType } from './types/literal.ts'
 import { NeverType } from './types/never.ts'
 import { BigIntType, IntegerType, NumberType } from './types/number.ts'
@@ -31,8 +26,9 @@ import {
   UnionType,
 } from './types/union.ts'
 
-export type { TSchema } from '@sinclair/typebox'
-export * from './schemas/nullable.ts'
+zod.config(zod.core.locales.en())
+
+export { NeemataTypeError } from './types/base.ts'
 export { BaseType, type BaseTypeAny } from './types/base.ts'
 export {
   ArrayType,
@@ -49,23 +45,24 @@ export {
   UnionType,
   AnyType,
   NeverType,
+  DiscriminatedUnionType,
+  RecordType,
 }
 
 export namespace type {
   export namespace infer {
-    export type decoded<T extends BaseTypeAny<any>> = StaticOutputDecode<
-      T['schema']
-    >
-    export type encoded<T extends BaseTypeAny<any>> = StaticOutputEncode<
-      T['schema']
-    >
+    export type decoded<T extends BaseTypeAny> =
+      T['decodedZodType']['_zod']['output']
+
+    export type encoded<T extends BaseTypeAny> =
+      T['encodedZodType']['_zod']['output']
+
     export namespace input {
-      export type decoded<T extends BaseTypeAny<any>> = StaticInputDecode<
-        T['schema']
-      >
-      export type encoded<T extends BaseTypeAny<any>> = StaticInputEncode<
-        T['schema']
-      >
+      export type decoded<T extends BaseTypeAny> =
+        T['decodedZodType']['_zod']['input']
+
+      export type encoded<T extends BaseTypeAny> =
+        T['encodedZodType']['_zod']['input']
     }
   }
 
@@ -76,14 +73,15 @@ export namespace type {
   export const integer = IntegerType.factory
   export const bitint = BigIntType.factory
   export const literal = LiteralType.factory
-  export const objectEnum = ObjectEnumType.factory
-  export const arrayEnum = EnumType.factory
+  export const enumeration = EnumType.factory
   export const date = DateType.factory
   export const array = ArrayType.factory
   export const record = RecordType.factory
   export const any = AnyType.factory
   export const or = UnionType.factory
   export const and = IntersactionType.factory
+  export const union = UnionType.factory
+  export const intersaction = IntersactionType.factory
   export const discriminatedUnion = DiscriminatedUnionType.factory
   export const custom = CustomType.factory
   export const object = Object.assign(ObjectType.factory.bind(ObjectType), {
@@ -96,4 +94,4 @@ export namespace type {
   })
 }
 
-export { type as t }
+export { type as t, zod }

package/src/temporal.ts

@@ -16,7 +16,7 @@ export const duration = DurationType.factory
 export const plainYearMonth = PlainYearMonthType.factory
 export const plainMonthDay = PlainMonthDayType.factory
 
-export {
+export type {
   DurationType,
   PlainDateTimeType,
   PlainDateType,

package/src/types/any.ts

@@ -1,8 +1,10 @@
-import { type TAny, Type } from '@sinclair/typebox'
+import { any, type ZodMiniAny } from '@zod/mini'
 import { BaseType } from './base.ts'
 
-export class AnyType extends BaseType<TAny, {}, any> {
+export class AnyType extends BaseType<ZodMiniAny> {
   static factory() {
-    return new AnyType(Type.Any())
+    return new AnyType({
+      encodedZodType: any(),
+    })
   }
 }

package/src/types/array.ts

@@ -1,38 +1,53 @@
 import {
-  type ArrayOptions,
-  type StaticDecode,
-  type TArray,
-  Type,
-} from '@sinclair/typebox'
+  array,
+  type core,
+  length,
+  maxLength,
+  minLength,
+  type ZodMiniArray,
+} from '@zod/mini'
 import { BaseType } from './base.ts'
 
+type Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>
+
 export class ArrayType<T extends BaseType = BaseType> extends BaseType<
-  TArray<T['schema']>,
-  { element: T; options: ArrayOptions }
+  ZodMiniArray<T['encodedZodType']>,
+  ZodMiniArray<T['decodedZodType']>,
+  { element: T }
 > {
-  static factory<T extends BaseType>(element: T, options: ArrayOptions = {}) {
-    return new ArrayType<T>(Type.Array(element.schema, options))
+  static factory<T extends BaseType>(element: T, ...checks: Check[]) {
+    return new ArrayType<T>({
+      encodedZodType: array(element.encodedZodType).check(...checks),
+      decodedZodType: array(element.decodedZodType).check(...checks),
+      params: { checks },
+      props: { element },
+    })
   }
 
   min(value: number) {
-    return ArrayType.factory(this.props.element, {
-      ...this.props.options,
-      minItems: value,
-    })
+    const check = minLength(value)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 
   max(value: number) {
-    return ArrayType.factory(this.props.element, {
-      ...this.props.options,
-      maxItems: value,
-    })
+    const check = maxLength(value)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 
   length(value: number) {
-    return ArrayType.factory(this.props.element, {
-      ...this.props.options,
-      minItems: value,
-      maxItems: value,
-    })
+    const check = length(value)
+    return ArrayType.factory<T>(
+      this.props.element,
+      ...this.params.checks,
+      check,
+    )
   }
 }

package/src/types/base.ts

@@ -1,139 +1,207 @@
-import { Optional, type TOptional, type TSchema } from '@sinclair/typebox'
-import { Default, type TDefault } from '../schemas/default.ts'
-import { Nullable, type TNullable } from '../schemas/nullable.ts'
+import {
+  _default,
+  core,
+  nullable,
+  optional,
+  registry,
+  type ZodMiniAny,
+  type ZodMiniArray,
+  type ZodMiniBoolean,
+  type ZodMiniDefault,
+  type ZodMiniEnum,
+  type ZodMiniInterface,
+  type ZodMiniIntersection,
+  type ZodMiniLiteral,
+  type ZodMiniNever,
+  type ZodMiniNullable,
+  type ZodMiniNumber,
+  type ZodMiniObject,
+  type ZodMiniOptional,
+  type ZodMiniPipe,
+  type ZodMiniRecord,
+  type ZodMiniString,
+  type ZodMiniType,
+  type ZodMiniUnion,
+} from '@zod/mini'
+
+export type PrimitiveValueType = string | number | boolean | null
+
+export type SimpleZodType =
+  | ZodMiniNever
+  | ZodMiniDefault
+  | ZodMiniNullable
+  | ZodMiniOptional
+  | ZodMiniString
+  | ZodMiniObject
+  | ZodMiniAny
+  | ZodMiniArray
+  | ZodMiniBoolean
+  | ZodMiniNumber
+  | ZodMiniEnum<any>
+  | ZodMiniLiteral<PrimitiveValueType>
+  | ZodMiniUnion
+  | ZodMiniIntersection
+  | ZodMiniInterface
+  | ZodMiniRecord
+  | ZodMiniPipe
+
+export type ZodType = SimpleZodType | ZodMiniType
 
 export type TypeProps = Record<string, any>
 
+export type TypeMetadata<T = any> = {
+  id?: string
+  description?: string
+  examples?: T[]
+  title?: string
+}
+
 export type TypeParams = {
-  optional?: boolean
-  nullable?: boolean
-  hasDefault?: boolean
   encode?: (value: any) => any
+  metadata?: TypeMetadata
+  checks: Array<core.CheckFn<any> | core.$ZodCheck<any>>
 }
 
 export type DefaultTypeParams = {
-  optional: false
-  nullable: false
-  hasDefault: false
   encode?: TypeParams['encode']
+  metadata?: TypeMetadata
 }
 
-export type BaseTypeAny<T extends TSchema = TSchema> = BaseType<
-  T,
-  TypeProps,
-  any
->
+export type BaseTypeAny<
+  EncodedZodType extends SimpleZodType = SimpleZodType,
+  DecodedZodType extends ZodType = ZodMiniType,
+> = BaseType<EncodedZodType, DecodedZodType, TypeProps>
+
+export const typesRegistry = registry<TypeMetadata>()
+
+export const NeemataTypeError = core.$ZodError
+export type NeemataTypeError = core.$ZodError
 
 export abstract class BaseType<
-  Schema extends TSchema = TSchema,
+  EncodedZodType extends SimpleZodType = SimpleZodType,
+  DecodedZodType extends ZodType = EncodedZodType,
   Props extends TypeProps = TypeProps,
-  ValueType = unknown,
 > {
-  readonly schema: Schema
+  readonly encodedZodType: EncodedZodType
+  readonly decodedZodType: DecodedZodType
   readonly props: Props
   readonly params: TypeParams
 
-  constructor(
-    schema: Schema,
-    props: Props = {} as Props,
-    params: TypeParams = {} as TypeParams,
-  ) {
-    const { hasDefault = false, nullable = false, optional = false } = params
-    this.schema = schema
+  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 = {
-      hasDefault,
-      nullable,
-      optional,
-    } as TypeParams
+    this.params = Object.assign({ checks: [] }, params)
   }
 
-  optional(): OptionalType<BaseType<Schema, Props>, ValueType> {
-    return OptionalType.factory(this) as any
+  optional(): OptionalType<this> {
+    return OptionalType.factory(this)
   }
 
-  nullable(): NullableType<BaseType<Schema, Props>, ValueType> {
-    return NullableType.factory(this) as any
+  nullable(): NullableType<this> {
+    return NullableType.factory(this)
   }
 
   nullish() {
     return this.nullable().optional()
   }
 
-  default(value: ValueType): DefaultType<BaseType<Schema, Props>, ValueType> {
-    return DefaultType.factory(
-      this,
-      this.params.encode?.(value) ?? value,
-    ) as any
+  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['decodedZodType']['_zod']['input'][]): this {
+    return this.meta({
+      examples: this.params.encode
+        ? examples.map(this.params.encode)
+        : examples,
+    })
   }
 
-  description(description: string): BaseType<Schema, Props, ValueType> {
-    const ThisConstructor = this.constructor as any
-    return new ThisConstructor(
-      {
-        ...this.schema,
-        description,
-      },
-      this.props,
-      this.params,
-    ) as any
+  meta(newMetadata: TypeMetadata): this {
+    const metadata = typesRegistry.get(this.encodedZodType) ?? {}
+    Object.assign(metadata, newMetadata)
+    typesRegistry.add(this.encodedZodType, metadata)
+    return this
   }
 
-  examples(...examples: ValueType[]): BaseType<Schema, Props, ValueType> {
-    const ThisConstructor = this.constructor as any
-    return new ThisConstructor(
-      {
-        ...this.schema,
-        examples,
-      },
-      this.props,
-      this.params,
-    ) as any
+  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,
-  ValueType = unknown,
-> extends BaseType<TOptional<Type['schema']>, { inner: Type }, ValueType> {
+> extends BaseType<
+  ZodMiniOptional<Type['encodedZodType']>,
+  ZodMiniOptional<Type['decodedZodType']>,
+  { inner: Type }
+> {
   static factory<T extends BaseTypeAny>(type: T) {
-    return new OptionalType<T>(Optional(type.schema) as any, { inner: type }, {
-      ...type.params,
-      optional: true,
-    } as any)
+    return new OptionalType<T>({
+      encodedZodType: optional(type.encodedZodType) as any,
+      props: { inner: type },
+    })
   }
 }
 
 export class NullableType<
   Type extends BaseTypeAny<any> = BaseTypeAny<any>,
-  ValueType = unknown,
 > extends BaseType<
-  TNullable<Type['schema']>,
-  { inner: Type },
-  ValueType | null
+  ZodMiniNullable<Type['encodedZodType']>,
+  ZodMiniNullable<Type['decodedZodType']>,
+  { inner: Type }
 > {
   static factory<T extends BaseTypeAny<any>>(type: T) {
-    return new NullableType<T>(Nullable(type.schema), { inner: type }, {
-      ...type.params,
-      nullable: true,
-    } as any)
+    return new NullableType<T>({
+      encodedZodType: nullable(type.encodedZodType),
+      props: { inner: type },
+    })
   }
 }
 
 export class DefaultType<
   Type extends BaseTypeAny = BaseTypeAny,
-  ValueType = unknown,
 > extends BaseType<
-  TDefault<TOptional<Type['schema']>>,
-  { inner: Type },
-  ValueType
+  ZodMiniDefault<Type['encodedZodType']>,
+  ZodMiniDefault<Type['decodedZodType']>,
+  { inner: Type }
 > {
   static factory<T extends BaseTypeAny<any>>(type: T, defaultValue: any) {
-    return new DefaultType<T>(
-      Default(Optional(type.schema), defaultValue) as any,
-      { inner: type },
-      { ...type.params, hasDefault: true } as any,
-    )
+    return new DefaultType<T>({
+      encodedZodType: _default(
+        type.encodedZodType,
+        type.params.encode?.(defaultValue) ?? defaultValue,
+      ) as any,
+      decodedZodType: _default(type.decodedZodType, defaultValue) as any,
+      props: { inner: type },
+    })
   }
 }

package/src/types/boolean.ts

@@ -1,8 +1,10 @@
-import { type TBoolean, Type } from '@sinclair/typebox'
+import { boolean, type ZodMiniBoolean } from '@zod/mini'
 import { BaseType } from './base.ts'
 
-export class BooleanType extends BaseType<TBoolean, {}, boolean> {
+export class BooleanType extends BaseType<ZodMiniBoolean<boolean>> {
   static factory() {
-    return new BooleanType(Type.Boolean())
+    return new BooleanType({
+      encodedZodType: boolean(),
+    })
   }
 }

package/src/types/custom.ts

@@ -1,33 +1,66 @@
 import {
-  type TAny,
-  type TSchema,
-  type TTransform,
-  Type,
-} from '@sinclair/typebox'
-import type { StaticInputDecode, StaticOutputDecode } from '../inference.ts'
-import { BaseType } from './base.ts'
+  any,
+  type core,
+  custom,
+  overwrite,
+  pipe,
+  type ZodMiniAny,
+  type ZodMiniCustom,
+  type ZodMiniPipe,
+} from '@zod/mini'
+import { BaseType, type SimpleZodType, type ZodType } from './base.ts'
 
-export type CustomTypeDecode<T> = (value: any) => T
-export type CustomTypeEncode<T> = (value: T) => any
+export type CustomTypeDecode<I, O> = (value: I) => O
+export type CustomTypeEncode<I, O> = (value: I) => O
 
 export abstract class TransformType<
-  T,
-  S extends TSchema = TAny,
-> extends BaseType<TTransform<S, T>, {}, StaticInputDecode<TTransform<S, T>>> {}
+  Type,
+  EncodedType extends SimpleZodType = ZodMiniAny,
+  DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
+> extends BaseType<
+  ZodMiniPipe<
+    ZodMiniCustom<DecodedType['_zod']['output'], DecodedType['_zod']['input']>,
+    EncodedType
+  >,
+  ZodMiniPipe<
+    EncodedType,
+    ZodMiniCustom<EncodedType['_zod']['output'], EncodedType['_zod']['input']>
+  >
+> {}
 
-export class CustomType<T, S extends TSchema = TAny> extends TransformType<
-  T,
-  S
-> {
-  static factory<T, S extends TSchema = TAny>(
-    decode: CustomTypeDecode<T>,
-    encode: CustomTypeEncode<T>,
-    schema: S = Type.Any() as S,
-  ) {
-    return new CustomType<T, S>(
-      Type.Transform(schema).Decode(decode).Encode(encode),
-      {},
-      { encode } as any,
-    )
+export class CustomType<
+  Type,
+  EncodedType extends SimpleZodType = ZodMiniAny,
+  DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
+> extends TransformType<Type, EncodedType, DecodedType> {
+  static factory<
+    Type,
+    EncodedType extends SimpleZodType = ZodMiniAny,
+    DecodedType extends ZodType = ZodMiniCustom<Type, Type>,
+  >({
+    decode,
+    encode,
+    error,
+    type = any() as unknown as EncodedType,
+  }: {
+    decode: CustomTypeDecode<
+      EncodedType['_zod']['input'],
+      DecodedType['_zod']['output']
+    >
+    encode: CustomTypeEncode<
+      DecodedType['_zod']['input'],
+      EncodedType['_zod']['output']
+    >
+    error?: string | core.$ZodErrorMap<core.$ZodIssueBase>
+    type?: EncodedType
+  }) {
+    return new CustomType<Type, EncodedType, DecodedType>({
+      encodedZodType: pipe(custom().check(overwrite(encode)), type),
+      decodedZodType: pipe(
+        type,
+        custom(undefined, { error }).check(overwrite(decode)),
+      ),
+      params: { encode },
+    })
   }
 }