@nmtjs/type 0.15.0-beta.36 → 0.15.0-beta.37

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2025 Denys Ilchyshyn
+Copyright (c) 2024 Denis Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -6,4 +6,4 @@
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers

package/dist/index.d.ts

@@ -1,7 +1,4 @@
 import * as type from './types/_type.ts';
-export * from './types/_convert.ts';
-export * from './types/_utils.ts';
 export * from './types/base.ts';
 export { type, type as t };
 export default type;
-export declare function registerDefaultLocale(): void;

package/dist/index.js

@@ -1,12 +1,7 @@
 import { en } from 'zod/locales';
 import { config } from 'zod/mini';
-import * as type from './types/_type.js';
-export * from './types/_convert.js';
-export * from './types/_utils.js';
-export * from './types/base.js';
+import * as type from "./types/_type.js";
+config(en());
+export * from "./types/base.js";
 export { type, type as t };
 export default type;
-export function registerDefaultLocale() {
-    config(en());
-}
-//# sourceMappingURL=index.js.map

package/dist/temporal/global.d.ts

@@ -1,9 +1,8 @@
 import 'temporal-spec/global';
-import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType } from '../types/temporal.ts';
-export declare const plainDate: () => PlainDateType;
-export declare const plainDatetime: () => PlainDateTimeType;
-export declare const plainTime: () => PlainTimeType;
-export declare const zonedDatetime: () => ZonedDateTimeType;
-export declare const duration: () => DurationType;
-export declare const plainYearMonth: () => PlainYearMonthType;
-export declare const plainMonthDay: () => PlainMonthDayType;
+export declare const plainDate: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainDate, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainDate, import("temporal-spec").Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainDate, import("temporal-spec").Temporal.PlainDate>>>;
+export declare const plainDatetime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainDateTime, import("temporal-spec").Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainDateTime, import("temporal-spec").Temporal.PlainDateTime>>>;
+export declare const plainTime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainTime, import("temporal-spec").Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainTime, import("temporal-spec").Temporal.PlainTime>>>;
+export declare const zonedDatetime: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.ZonedDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.ZonedDateTime, import("temporal-spec").Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.ZonedDateTime, import("temporal-spec").Temporal.ZonedDateTime>>>;
+export declare const duration: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.Duration, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.Duration, import("temporal-spec").Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.Duration, import("temporal-spec").Temporal.Duration>>>;
+export declare const plainYearMonth: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainYearMonth, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainYearMonth, import("temporal-spec").Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainYearMonth, import("temporal-spec").Temporal.PlainYearMonth>>>;
+export declare const plainMonthDay: () => import("../types/custom.ts").CustomType<import("temporal-spec").Temporal.PlainMonthDay, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<import("temporal-spec").Temporal.PlainMonthDay, import("temporal-spec").Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<import("temporal-spec").Temporal.PlainMonthDay, import("temporal-spec").Temporal.PlainMonthDay>>>;

package/dist/temporal/global.js

@@ -1,5 +1,5 @@
 import 'temporal-spec/global';
-import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from '../types/temporal.js';
+import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from "../types/temporal.js";
 export const plainDate = PlainDateType.factory.bind(PlainDateType, Temporal);
 export const plainDatetime = PlainDateTimeType.factory.bind(PlainDateTimeType, Temporal);
 export const plainTime = PlainTimeType.factory.bind(PlainTimeType, Temporal);
@@ -7,4 +7,3 @@ export const zonedDatetime = ZonedDateTimeType.factory.bind(ZonedDateTimeType, T
 export const duration = DurationType.factory.bind(DurationType, Temporal);
 export const plainYearMonth = PlainYearMonthType.factory.bind(PlainYearMonthType, Temporal);
 export const plainMonthDay = PlainMonthDayType.factory.bind(PlainMonthDayType, Temporal);
-//# sourceMappingURL=global.js.map

package/dist/temporal/polyfill.d.ts

@@ -1,8 +1,8 @@
-import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType } from '../types/temporal.ts';
-export declare const plainDate: () => PlainDateType;
-export declare const plainDatetime: () => PlainDateTimeType;
-export declare const plainTime: () => PlainTimeType;
-export declare const zonedDatetime: () => ZonedDateTimeType;
-export declare const duration: () => DurationType;
-export declare const plainYearMonth: () => PlainYearMonthType;
-export declare const plainMonthDay: () => PlainMonthDayType;
+import { Temporal } from 'temporal-polyfill';
+export declare const plainDate: () => import("../types/custom.ts").CustomType<Temporal.PlainDate, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
+export declare const plainDatetime: () => import("../types/custom.ts").CustomType<Temporal.PlainDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
+export declare const plainTime: () => import("../types/custom.ts").CustomType<Temporal.PlainTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
+export declare const zonedDatetime: () => import("../types/custom.ts").CustomType<Temporal.ZonedDateTime, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
+export declare const duration: () => import("../types/custom.ts").CustomType<Temporal.Duration, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
+export declare const plainYearMonth: () => import("../types/custom.ts").CustomType<Temporal.PlainYearMonth, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
+export declare const plainMonthDay: () => import("../types/custom.ts").CustomType<Temporal.PlainMonthDay, import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;

package/dist/temporal/polyfill.js

@@ -1,5 +1,5 @@
 import { Temporal } from 'temporal-polyfill';
-import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from '../types/temporal.js';
+import { DurationType, PlainDateTimeType, PlainDateType, PlainMonthDayType, PlainTimeType, PlainYearMonthType, ZonedDateTimeType, } from "../types/temporal.js";
 export const plainDate = PlainDateType.factory.bind(PlainDateType, Temporal);
 export const plainDatetime = PlainDateTimeType.factory.bind(PlainDateTimeType, Temporal);
 export const plainTime = PlainTimeType.factory.bind(PlainTimeType, Temporal);
@@ -7,4 +7,3 @@ export const zonedDatetime = ZonedDateTimeType.factory.bind(ZonedDateTimeType, T
 export const duration = DurationType.factory.bind(DurationType, Temporal);
 export const plainYearMonth = PlainYearMonthType.factory.bind(PlainYearMonthType, Temporal);
 export const plainMonthDay = PlainMonthDayType.factory.bind(PlainMonthDayType, Temporal);
-//# sourceMappingURL=polyfill.js.map

package/dist/types/{_utils.d.ts → _plain.d.ts}

@@ -1,5 +1,4 @@
 import type { core, ZodMiniType } from 'zod/mini';
-import type { BaseType } from './base.ts';
 export declare const PlainType: unique symbol;
 export type PlainType = typeof PlainType;
 export type ZodPlainType<T extends ZodMiniType<any, any, any>> = T & ZodMiniType<T['_zod']['output'] & {
@@ -12,4 +11,3 @@ export type ZodPlainType<T extends ZodMiniType<any, any, any>> = T & ZodMiniType
     [PlainType]?: true;
 }>>;
 export declare const zodPlainType: <T extends ZodMiniType<any, any, any>>(type: T) => ZodPlainType<T>;
-export type AnyCompatibleType<Encoded = any, Decoded = any> = BaseType<ZodMiniType<any, Decoded>, ZodMiniType<any, Encoded>>;

package/dist/types/{_utils.js → _plain.js}

@@ -1,3 +1,2 @@
 export const PlainType = Symbol('PlainType');
 export const zodPlainType = (type) => type;
-//# sourceMappingURL=_utils.js.map

package/dist/types/_type.d.ts

@@ -1,14 +1,12 @@
 import type { BaseTypeAny } from './base.ts';
 export * from './any.ts';
 export * from './array.ts';
-export { BaseType, type BaseTypeAny, DefaultType, NeemataTypeError, NullableType, OptionalType, } from './base.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 './null.ts';
 export * from './number.ts';
 export * from './object.ts';
 export * from './string.ts';

package/dist/types/_type.js

@@ -1,16 +1,13 @@
-export * from './any.js';
-export * from './array.js';
-export { BaseType, DefaultType, NeemataTypeError, NullableType, OptionalType, } from './base.js';
-export * from './boolean.js';
-export * from './custom.js';
-export * from './date.js';
-export * from './enum.js';
-export * from './literal.js';
-export * from './never.js';
-export * from './null.js';
-export * from './number.js';
-export * from './object.js';
-export * from './string.js';
-export * from './tuple.js';
-export * from './union.js';
-//# sourceMappingURL=_type.js.map
+export * from "./any.js";
+export * from "./array.js";
+export * from "./boolean.js";
+export * from "./custom.js";
+export * from "./date.js";
+export * from "./enum.js";
+export * from "./literal.js";
+export * from "./never.js";
+export * from "./number.js";
+export * from "./object.js";
+export * from "./string.js";
+export * from "./tuple.js";
+export * from "./union.js";

package/dist/types/any.js

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

package/dist/types/array.d.ts

@@ -1,5 +1,5 @@
 import type { core, ZodMiniArray } from 'zod/mini';
-import type { ZodPlainType } from './_utils.ts';
+import type { ZodPlainType } from './_plain.ts';
 import { BaseType } from './base.ts';
 type Check = core.CheckFn<any[]> | core.$ZodCheck<any[]>;
 export declare class ArrayType<T extends BaseType = BaseType> extends BaseType<ZodMiniArray<T['encodeZodType']>, ZodMiniArray<T['decodeZodType']>, {

package/dist/types/array.js

@@ -1,5 +1,5 @@
 import { length, maxLength, minLength, array as zodArray } from 'zod/mini';
-import { BaseType } from './base.js';
+import { BaseType } from "./base.js";
 export class ArrayType extends BaseType {
     static factory(element, ...checks) {
         return new ArrayType({
@@ -23,4 +23,3 @@ export class ArrayType extends BaseType {
     }
 }
 export const array = ArrayType.factory;
-//# sourceMappingURL=array.js.map

package/dist/types/base.d.ts

@@ -31,7 +31,7 @@ export declare abstract class BaseType<EncodeZodType extends SimpleZodType = Sim
     readonly decodeRawZodType: RawDecodeZodType;
     readonly props: Props;
     readonly params: TypeParams;
-    constructor({ encodeZodType, decodeZodType, props, params }: {
+    constructor({ encodeZodType, decodeZodType, props, params, }: {
         encodeZodType: EncodeZodType;
         decodeZodType?: DecodeZodType;
         props?: Props;

package/dist/types/base.js

@@ -79,4 +79,3 @@ export class DefaultType extends BaseType {
         });
     }
 }
-//# sourceMappingURL=base.js.map

package/dist/types/boolean.js

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

package/dist/types/custom.d.ts

@@ -1,4 +1,3 @@
-import type { MaybePromise } from '@nmtjs/common';
 import type { core, ZodMiniType } from 'zod/mini';
 import type { SimpleZodType, ZodType } from './base.ts';
 import { BaseType } from './base.ts';
@@ -6,16 +5,11 @@ export type CustomTransformFn<I, O> = (value: I) => O;
 export declare abstract class TransformType<Type, EncodeType extends SimpleZodType = ZodMiniType<Type, Type>, DecodeType extends ZodType = ZodMiniType<Type, Type>> extends BaseType<ZodMiniType<EncodeType['_zod']['output'], DecodeType['_zod']['input']>, ZodMiniType<DecodeType['_zod']['output'], EncodeType['_zod']['input']>> {
 }
 export declare class CustomType<Type, EncodeType extends SimpleZodType = ZodMiniType<Type, Type>, DecodeType extends ZodType = ZodMiniType<Type, Type>> extends TransformType<Type, EncodeType, DecodeType> {
-    static factory<Type, EncodeType extends SimpleZodType = ZodMiniType<Type, Type>, DecodeType extends ZodType = ZodMiniType<Type, Type>>({ decode, encode, validation, error, type, prototype }: {
+    static factory<Type, EncodeType extends SimpleZodType = ZodMiniType<Type, Type>, DecodeType extends ZodType = ZodMiniType<Type, Type>>({ decode, encode, error, type, }: {
         decode: CustomTransformFn<EncodeType['_zod']['input'], DecodeType['_zod']['output']>;
         encode: CustomTransformFn<DecodeType['_zod']['input'], EncodeType['_zod']['output']>;
-        validation?: ((value: EncodeType['_zod']['input'] | DecodeType['_zod']['output'], payload: core.$RefinementCtx<EncodeType['_zod']['output'] | DecodeType['_zod']['output']>) => MaybePromise<void>) | {
-            encode?: (value: EncodeType['_zod']['input'], payload: core.$RefinementCtx<EncodeType['_zod']['output']>) => MaybePromise<void>;
-            decode?: (value: DecodeType['_zod']['output'], payload: core.$RefinementCtx<DecodeType['_zod']['output']>) => MaybePromise<void>;
-        };
         error?: string | core.$ZodErrorMap<core.$ZodIssueBase>;
         type?: EncodeType;
-        prototype?: object;
     }): CustomType<Type, EncodeType, DecodeType>;
 }
 export declare const custom: typeof CustomType.factory;

package/dist/types/custom.js

@@ -1,33 +1,16 @@
-import { any, overwrite, pipe, refine, superRefine, custom as zodCustom, } from 'zod/mini';
-import { BaseType } from './base.js';
+import { any, overwrite, pipe, refine, custom as zodCustom } from 'zod/mini';
+import { BaseType } from "./base.js";
 export class TransformType extends BaseType {
 }
 export class CustomType extends TransformType {
-    static factory({ decode, encode, validation, error, type = any(), prototype, }) {
-        const _validation = validation
-            ? typeof validation === 'function'
-                ? { encode: validation, decode: validation }
-                : validation
-            : undefined;
-        const instance = new CustomType({
-            encodeZodType: pipe(zodCustom().check(...[
-                refine((val) => typeof val !== 'undefined', { abort: true }),
-                _validation?.encode ? superRefine(_validation.encode) : undefined,
-                overwrite(encode),
-            ].filter((v) => !!v)), type),
+    static factory({ decode, encode, error, type = any(), }) {
+        return new CustomType({
+            encodeZodType: pipe(zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(encode)), type),
             decodeZodType: pipe(type, 
             // @ts-expect-error
-            zodCustom().check(...[
-                refine((val) => typeof val !== 'undefined', { abort: true }),
-                overwrite(decode),
-                _validation?.decode ? superRefine(_validation.decode) : undefined,
-            ].filter((v) => !!v))),
+            zodCustom().check(refine((val) => typeof val !== 'undefined', { error, abort: true }), overwrite(decode))),
             params: { encode },
         });
-        if (prototype)
-            Object.setPrototypeOf(instance, prototype);
-        return instance;
     }
 }
 export const custom = CustomType.factory;
-//# sourceMappingURL=custom.js.map

package/dist/types/date.d.ts

@@ -1,7 +1,7 @@
 import type { ZodMiniUnion } from 'zod/mini';
 import { iso } from 'zod/mini';
-import { TransformType } from './custom.ts';
+import { CustomType, TransformType } from './custom.ts';
 export declare class DateType extends TransformType<Date, ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>> {
-    static factory(): DateType;
+    static factory(): CustomType<Date, ZodMiniUnion<[iso.ZodMiniISODate, iso.ZodMiniISODateTime]>, import("zod/mini").ZodMiniType<Date, Date, import("zod/v4/core").$ZodTypeInternals<Date, Date>>>;
 }
 export declare const date: typeof DateType.factory;

package/dist/types/date.js

@@ -1,14 +1,12 @@
 import { iso, union } from 'zod/mini';
-import { CustomType, TransformType } from './custom.js';
+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.date(), iso.datetime()]),
-            prototype: DateType.prototype,
         });
     }
 }
 export const date = DateType.factory;
-//# sourceMappingURL=date.js.map

package/dist/types/enum.js

@@ -1,5 +1,5 @@
 import { enum as zodEnum } from 'zod/mini';
-import { BaseType } from './base.js';
+import { BaseType } from "./base.js";
 export class EnumType extends BaseType {
     static factory(values) {
         return new EnumType({
@@ -10,4 +10,3 @@ export class EnumType extends BaseType {
 }
 const _enum = EnumType.factory;
 export { _enum as enum };
-//# sourceMappingURL=enum.js.map

package/dist/types/literal.js

@@ -1,5 +1,5 @@
 import { literal as zodLiteral } from 'zod/mini';
-import { BaseType } from './base.js';
+import { BaseType } from "./base.js";
 export class LiteralType extends BaseType {
     static factory(value) {
         return new LiteralType({
@@ -9,4 +9,3 @@ export class LiteralType extends BaseType {
     }
 }
 export const literal = LiteralType.factory;
-//# sourceMappingURL=literal.js.map

package/dist/types/never.js

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

package/dist/types/number.js

@@ -1,6 +1,6 @@
 import { gt, gte, int, lt, lte, regex, number as zodNumber, string as zodString, } from 'zod/mini';
-import { BaseType } from './base.js';
-import { CustomType, TransformType } from './custom.js';
+import { BaseType } from "./base.js";
+import { CustomType, TransformType } from "./custom.js";
 export class NumberType extends BaseType {
     static factory(...checks) {
         return new NumberType({
@@ -45,4 +45,3 @@ export class BigIntType extends TransformType {
 export const number = NumberType.factory;
 export const integer = IntegerType.factory;
 export const bigInt = BigIntType.factory;
-//# sourceMappingURL=number.js.map

package/dist/types/object.d.ts

@@ -1,5 +1,5 @@
 import type { core, ZodMiniObject, ZodMiniRecord } from 'zod/mini';
-import type { ZodPlainType } from './_utils.ts';
+import type { ZodPlainType } from './_plain.ts';
 import type { BaseTypeAny, OptionalType } from './base.ts';
 import type { LiteralType } from './literal.ts';
 import type { StringType } from './string.ts';
@@ -8,72 +8,45 @@ import { EnumType } from './enum.ts';
 export type ObjectTypeProps = {
     [k: string]: BaseTypeAny;
 };
+export type AnyObjectType = ObjectType<ObjectTypeProps>;
 export declare class ObjectType<T extends ObjectTypeProps = {}> extends BaseType<ZodMiniObject<{
     [K in keyof T]: T[K]['encodeZodType'];
-}, core.$strip>, ZodMiniObject<{
+}, core.$strict>, ZodMiniObject<{
     [K in keyof T]: T[K]['decodeZodType'];
-}, core.$strip>, {
+}, core.$strict>, {
     properties: T;
 }, ZodPlainType<ZodMiniObject<{
     [K in keyof T]: T[K]['encodeZodType'];
-}, core.$strip>>, ZodPlainType<ZodMiniObject<{
+}, core.$strict>>, ZodPlainType<ZodMiniObject<{
     [K in keyof T]: T[K]['decodeZodType'];
-}, core.$strip>>> {
+}, core.$strict>>> {
     static factory<T extends ObjectTypeProps = {}>(properties: T): ObjectType<T>;
 }
-export declare class LooseObjectType<T extends ObjectTypeProps = {}> extends BaseType<ZodMiniObject<{
-    [K in keyof T]: T[K]['encodeZodType'];
-}, core.$loose>, ZodMiniObject<{
-    [K in keyof T]: T[K]['decodeZodType'];
-}, core.$loose>, {
-    properties: T;
-}, ZodPlainType<ZodMiniObject<{
-    [K in keyof T]: T[K]['encodeZodType'];
-}, core.$loose>>, ZodPlainType<ZodMiniObject<{
-    [K in keyof T]: T[K]['decodeZodType'];
-}, core.$loose>>> {
-    static factory<T extends ObjectTypeProps = {}>(properties: T): LooseObjectType<T>;
-}
-export type ObjectLikeType<T extends ObjectTypeProps> = ObjectType<T> | LooseObjectType<T>;
-export type AnyObjectType = ObjectType<ObjectTypeProps>;
-export type AnyLooseObjectType = LooseObjectType<ObjectTypeProps>;
-export type AnyObjectLikeType = AnyObjectType | AnyLooseObjectType;
 export declare class RecordType<K extends LiteralType<string | number> | EnumType | StringType, E extends BaseType> extends BaseType<ZodMiniRecord<K['encodeZodType'], E['encodeZodType']>, ZodMiniRecord<K['decodeZodType'], E['decodeZodType']>, {
     key: K;
     element: E;
 }, ZodPlainType<ZodMiniRecord<K['encodeZodType'], E['encodeZodType']>>, ZodPlainType<ZodMiniRecord<K['decodeZodType'], E['decodeZodType']>>> {
     static factory<K extends LiteralType<string | number> | EnumType | StringType, E extends BaseType>(key: K, element: E): RecordType<K, E>;
 }
-export type KeyofType<T extends AnyObjectLikeType> = EnumType<core.util.ToEnum<Extract<keyof T['props']['properties'], string>>>;
-export declare function keyof<T extends AnyObjectLikeType>(type: T): KeyofType<T>;
-export type PickObjectType<T extends AnyObjectLikeType, P extends {
+export declare function keyof<T extends AnyObjectType>(type: T): EnumType<core.util.ToEnum<Extract<keyof T['props']['properties'], string>>>;
+export declare function pick<T extends AnyObjectType, P extends {
     [K in keyof T['props']['properties']]?: true;
-}> = ObjectType<{
+}>(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;
 }>;
-export declare function pick<T extends AnyObjectLikeType, P extends {
+export declare function omit<T extends AnyObjectType, P extends {
     [K in keyof T['props']['properties']]?: true;
-}>(source: T, pick: P): PickObjectType<T, P>;
-export type OmitObjectType<T extends AnyObjectLikeType, P extends {
-    [K in keyof T['props']['properties']]?: true;
-}> = ObjectType<{
+}>(source: T, omit: P): ObjectType<{
     [K in keyof T['props']['properties'] as K extends keyof P ? never : K]: T['props']['properties'][K];
 }>;
-export declare function omit<T extends AnyObjectLikeType, P extends {
-    [K in keyof T['props']['properties']]?: true;
-}>(source: T, omit: P): OmitObjectType<T, P>;
-export type ExtendObjectType<T extends AnyObjectLikeType, P extends ObjectTypeProps> = ObjectType<{
+export declare 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;
 }>;
-export declare function extend<T extends AnyObjectLikeType, P extends ObjectTypeProps>(object1: T, properties: P): ExtendObjectType<T, P>;
-export type MergeObjectTypes<T1 extends AnyObjectLikeType, T2 extends AnyObjectLikeType> = ObjectType<{
+export declare 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;
 }>;
-export declare function merge<T1 extends AnyObjectLikeType, T2 extends AnyObjectLikeType>(object1: T1, object2: T2): MergeObjectTypes<T1, T2>;
-export type PartialObjectType<T extends AnyObjectLikeType> = ObjectType<{
-    [K in keyof T['props']['properties']]: OptionalType<T['props']['properties'][K]>;
+export declare function partial<T extends AnyObjectType, P extends T extends ObjectType<infer Props> ? Props : never>(object: T): ObjectType<{
+    [K in keyof P]: OptionalType<P[K]>;
 }>;
-export declare function partial<T extends AnyObjectLikeType>(object: T): PartialObjectType<T>;
 export declare const object: typeof ObjectType.factory;
-export declare const looseObject: typeof LooseObjectType.factory;
 export declare const record: typeof RecordType.factory;

package/dist/types/object.js

@@ -1,7 +1,7 @@
-import { looseObject as zodLooseObject, object as zodObject, record as zodRecord, } from 'zod/mini';
-import { zodPlainType } from './_utils.js';
-import { BaseType } from './base.js';
-import { EnumType } from './enum.js';
+import { object as zodObject, record as zodRecord } from 'zod/mini';
+import { zodPlainType } from "./_plain.js";
+import { BaseType } from "./base.js";
+import { EnumType } from "./enum.js";
 export class ObjectType extends BaseType {
     static factory(properties) {
         const encodeProperties = {};
@@ -17,21 +17,6 @@ export class ObjectType extends BaseType {
         });
     }
 }
-export class LooseObjectType extends BaseType {
-    static factory(properties) {
-        const encodeProperties = {};
-        const decodeProperties = {};
-        for (const key in properties) {
-            encodeProperties[key] = properties[key].encodeZodType;
-            decodeProperties[key] = properties[key].decodeZodType;
-        }
-        return new LooseObjectType({
-            encodeZodType: zodLooseObject(encodeProperties),
-            decodeZodType: zodLooseObject(decodeProperties),
-            props: { properties },
-        });
-    }
-}
 export class RecordType extends BaseType {
     static factory(key, element) {
         return new RecordType({
@@ -72,6 +57,4 @@ export function partial(object) {
     return ObjectType.factory(properties);
 }
 export const object = ObjectType.factory;
-export const looseObject = LooseObjectType.factory;
 export const record = RecordType.factory;
-//# sourceMappingURL=object.js.map

package/dist/types/string.js

@@ -1,5 +1,5 @@
 import { cuid, cuid2, e164, email, emoji, ipv4, ipv6, jwt, maxLength, minLength, nanoid, regex, url, uuid, string as zodString, } from 'zod/mini';
-import { BaseType } from './base.js';
+import { BaseType } from "./base.js";
 export class StringType extends BaseType {
     static factory(...checks) {
         return new StringType({
@@ -51,4 +51,3 @@ export class StringType extends BaseType {
     }
 }
 export const string = StringType.factory;
-//# sourceMappingURL=string.js.map

package/dist/types/temporal.d.ts

@@ -1,26 +1,26 @@
 import type { Temporal } from 'temporal-spec';
 import type { ZodMiniString } from 'zod/mini';
-import { TransformType } from './custom.ts';
+import { CustomType, TransformType } from './custom.ts';
 type EncodeType = ZodMiniString<string>;
 export declare class PlainDateType extends TransformType<Temporal.PlainDate, EncodeType> {
-    static factory(implementation: typeof Temporal): PlainDateType;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainDate, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDate, Temporal.PlainDate, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDate, Temporal.PlainDate>>>;
 }
 export declare class PlainDateTimeType extends TransformType<Temporal.PlainDateTime, EncodeType> {
-    static factory(implementation: typeof Temporal): PlainDateTimeType;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainDateTime, Temporal.PlainDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainDateTime, Temporal.PlainDateTime>>>;
 }
 export declare class ZonedDateTimeType extends TransformType<Temporal.ZonedDateTime, EncodeType> {
-    static factory(implementation: typeof Temporal): ZonedDateTimeType;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.ZonedDateTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.ZonedDateTime, Temporal.ZonedDateTime, import("zod/v4/core").$ZodTypeInternals<Temporal.ZonedDateTime, Temporal.ZonedDateTime>>>;
 }
 export declare class PlainTimeType extends TransformType<Temporal.PlainTime, EncodeType> {
-    static factory(implementation: typeof Temporal): PlainTimeType;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainTime, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainTime, Temporal.PlainTime, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainTime, Temporal.PlainTime>>>;
 }
 export declare class DurationType extends TransformType<Temporal.Duration, EncodeType> {
-    static factory(implementation: typeof Temporal): DurationType;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.Duration, EncodeType, import("zod/mini").ZodMiniType<Temporal.Duration, Temporal.Duration, import("zod/v4/core").$ZodTypeInternals<Temporal.Duration, Temporal.Duration>>>;
 }
 export declare class PlainYearMonthType extends TransformType<Temporal.PlainYearMonth, EncodeType> {
-    static factory(implementation: typeof Temporal): PlainYearMonthType;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainYearMonth, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainYearMonth, Temporal.PlainYearMonth, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainYearMonth, Temporal.PlainYearMonth>>>;
 }
 export declare class PlainMonthDayType extends TransformType<Temporal.PlainMonthDay, EncodeType> {
-    static factory(implementation: typeof Temporal): PlainMonthDayType;
+    static factory(implementation: typeof Temporal): CustomType<Temporal.PlainMonthDay, EncodeType, import("zod/mini").ZodMiniType<Temporal.PlainMonthDay, Temporal.PlainMonthDay, import("zod/v4/core").$ZodTypeInternals<Temporal.PlainMonthDay, Temporal.PlainMonthDay>>>;
 }
 export {};

package/dist/types/temporal.js

@@ -1,5 +1,5 @@
 import { iso, regex, string } from 'zod/mini';
-import { CustomType, TransformType } from './custom.js';
+import { CustomType, TransformType } from "./custom.js";
 const createTemporalTransformer = (implementation, type, decode = (value) => implementation[type].from(value), encode = (value) => value.toString({
     calendarName: 'never',
     smallestUnit: 'microsecond',
@@ -91,4 +91,3 @@ export class PlainMonthDayType extends TransformType {
         });
     }
 }
-//# sourceMappingURL=temporal.js.map

package/dist/types/tuple.d.ts

@@ -1,6 +1,6 @@
 import type { ArrayMap } from '@nmtjs/common';
 import type { ZodMiniTuple } from 'zod/mini';
-import type { ZodPlainType } from './_utils.ts';
+import type { ZodPlainType } from './_plain.ts';
 import { BaseType } from './base.ts';
 export declare class TupleType<T extends readonly [BaseType, ...BaseType[]] = readonly [
     BaseType,

package/dist/types/tuple.js

@@ -1,5 +1,5 @@
 import { tuple as zodTuple } from 'zod/mini';
-import { BaseType } from './base.js';
+import { BaseType } from "./base.js";
 export class TupleType extends BaseType {
     static factory(elements, rest = null) {
         const encode = elements.map((el) => el.encodeZodType);
@@ -14,4 +14,3 @@ export class TupleType extends BaseType {
     }
 }
 export const tuple = TupleType.factory;
-//# sourceMappingURL=tuple.js.map

package/dist/types/union.d.ts

@@ -1,6 +1,6 @@
 import type { ArrayMap } from '@nmtjs/common';
 import type { ZodMiniDiscriminatedUnion, ZodMiniIntersection, ZodMiniUnion } from 'zod/mini';
-import type { ZodPlainType } from './_utils.ts';
+import type { ZodPlainType } from './_plain.ts';
 import type { BaseTypeAny } from './base.ts';
 import type { LiteralType } from './literal.ts';
 import type { ObjectType, ObjectTypeProps } from './object.ts';