@nmtjs/type 0.14.4 → 0.14.5

package/dist/types/_plain.d.ts

@@ -0,0 +1,13 @@
+import type { core, ZodMiniType } from 'zod/mini';
+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'] & {
+    [PlainType]?: true;
+}, T['_zod']['input'] & {
+    [PlainType]?: true;
+}, core.$ZodTypeInternals<T['_zod']['output'] & {
+    [PlainType]?: true;
+}, T['_zod']['input'] & {
+    [PlainType]?: true;
+}>>;
+export declare const zodPlainType: <T extends ZodMiniType<any, any, any>>(type: T) => ZodPlainType<T>;

package/dist/types/_plain.js

@@ -0,0 +1,2 @@
+export const PlainType = Symbol('PlainType');
+export const zodPlainType = (type) => type;

package/dist/types/_type.d.ts

@@ -21,4 +21,12 @@ export declare namespace infer {
         type input<T extends BaseTypeAny> = T['encodeZodType']['_zod']['input'];
         type output<T extends BaseTypeAny> = T['encodeZodType']['_zod']['output'];
     }
+    namespace decodeRaw {
+        type input<T extends BaseTypeAny> = T['decodeRawZodType']['_zod']['input'];
+        type output<T extends BaseTypeAny> = T['decodeRawZodType']['_zod']['output'];
+    }
+    namespace encodeRaw {
+        type input<T extends BaseTypeAny> = T['encodeRawZodType']['_zod']['input'];
+        type output<T extends BaseTypeAny> = T['encodeRawZodType']['_zod']['output'];
+    }
 }

package/dist/types/array.d.ts

@@ -1,9 +1,10 @@
 import type { core, ZodMiniArray } from 'zod/mini';
+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']>, {
     element: T;
-}> {
+}, ZodPlainType<ZodMiniArray<T['encodeZodType']>>, ZodPlainType<ZodMiniArray<T['encodeZodType']>>> {
     static factory<T extends BaseType>(element: T, ...checks: Check[]): ArrayType<T>;
     min(value: number): ArrayType<T>;
     max(value: number): ArrayType<T>;

package/dist/types/base.d.ts

@@ -24,9 +24,11 @@ export type BaseTypeAny<EncodedZodType extends SimpleZodType = SimpleZodType, De
 export declare const typesRegistry: core.$ZodRegistry<TypeMetadata<any>, core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>;
 export declare const NeemataTypeError: core.$constructor<core.$ZodError<unknown>, core.$ZodIssue[]>;
 export type NeemataTypeError = core.$ZodError;
-export declare abstract class BaseType<EncodeZodType extends SimpleZodType = SimpleZodType, DecodeZodType extends ZodType = EncodeZodType, Props extends TypeProps = TypeProps> {
+export declare abstract class BaseType<EncodeZodType extends SimpleZodType = SimpleZodType, DecodeZodType extends ZodType = EncodeZodType, Props extends TypeProps = TypeProps, RawEncodeZodType extends SimpleZodType = EncodeZodType, RawDecodeZodType extends ZodType = DecodeZodType> {
     readonly encodeZodType: EncodeZodType;
     readonly decodeZodType: DecodeZodType;
+    readonly encodeRawZodType: RawEncodeZodType;
+    readonly decodeRawZodType: RawDecodeZodType;
     readonly props: Props;
     readonly params: TypeParams;
     constructor({ encodeZodType, decodeZodType, props, params, }: {

package/dist/types/base.js

@@ -4,6 +4,8 @@ export const NeemataTypeError = core.$ZodError;
 export class BaseType {
     encodeZodType;
     decodeZodType;
+    encodeRawZodType;
+    decodeRawZodType;
     props;
     params;
     constructor({ encodeZodType, decodeZodType = encodeZodType, props = {}, params = {}, }) {

package/dist/types/object.d.ts

@@ -1,4 +1,5 @@
 import type { core, ZodMiniObject, ZodMiniRecord } from 'zod/mini';
+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';
@@ -14,13 +15,20 @@ export declare class ObjectType<T extends ObjectTypeProps = {}> extends BaseType
     [K in keyof T]: T[K]['decodeZodType'];
 }, core.$strict>, {
     properties: T;
-}> {
+}, ZodPlainType<ZodMiniObject<{
+    [K in keyof T]: T[K]['encodeZodType'];
+}, core.$strict>>, ZodPlainType<ZodMiniObject<{
+    [K in keyof T]: T[K]['decodeZodType'];
+}, core.$strict>>> {
     static factory<T extends ObjectTypeProps = {}>(properties: T): ObjectType<T>;
 }
-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']>> {
+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 declare function keyof<T extends ObjectType>(type: T): EnumType<core.util.ToEnum<Extract<keyof T['props']['properties'], string>>>;
+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;
 }>(source: T, pick: P): ObjectType<{

package/dist/types/object.js

@@ -1,4 +1,5 @@
 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 {
@@ -19,8 +20,8 @@ export class ObjectType extends BaseType {
 export class RecordType extends BaseType {
     static factory(key, element) {
         return new RecordType({
-            encodeZodType: zodRecord(key.encodeZodType, element.encodeZodType),
-            decodeZodType: zodRecord(key.decodeZodType, element.decodeZodType),
+            encodeZodType: zodPlainType(zodRecord(key.encodeZodType, element.encodeZodType)),
+            decodeZodType: zodPlainType(zodRecord(key.decodeZodType, element.decodeZodType)),
             props: { key, element },
         });
     }

package/dist/types/tuple.d.ts

@@ -1,5 +1,6 @@
 import type { ArrayMap } from '@nmtjs/common';
 import type { ZodMiniTuple } from 'zod/mini';
+import type { ZodPlainType } from './_plain.ts';
 import { BaseType } from './base.ts';
 export declare class TupleType<T extends readonly [BaseType, ...BaseType[]] = readonly [
     BaseType,
@@ -7,7 +8,7 @@ export declare class TupleType<T extends readonly [BaseType, ...BaseType[]] = re
 ], R extends BaseType | null = BaseType | null> extends BaseType<R extends BaseType ? ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, R['encodeZodType']> : ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, null>, R extends BaseType ? ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, R['decodeZodType']> : ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, null>, {
     elements: T;
     rest?: R;
-}> {
+}, R extends BaseType ? ZodPlainType<ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, R['encodeZodType']>> : ZodPlainType<ZodMiniTuple<ArrayMap<T, 'encodeZodType'>, null>>, R extends BaseType ? ZodPlainType<ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, R['decodeZodType']>> : ZodPlainType<ZodMiniTuple<ArrayMap<T, 'decodeZodType'>, null>>> {
     static factory<T extends readonly [BaseType, ...BaseType[]], R extends BaseType | null = null>(elements: T, rest?: R): TupleType<T, R>;
 }
 export declare const tuple: typeof TupleType.factory;

package/dist/types/union.d.ts

@@ -1,5 +1,6 @@
 import type { ArrayMap } from '@nmtjs/common';
 import type { ZodMiniDiscriminatedUnion, ZodMiniIntersection, ZodMiniUnion } from 'zod/mini';
+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';
@@ -9,7 +10,7 @@ export declare class UnionType<T extends readonly [BaseType, ...BaseType[]] = re
     ...BaseType[]
 ]> extends BaseType<ZodMiniUnion<ArrayMap<T, 'encodeZodType'>>, ZodMiniUnion<ArrayMap<T, 'decodeZodType'>>, {
     options: T;
-}> {
+}, ZodPlainType<ZodMiniUnion<ArrayMap<T, 'encodeZodType'>>>, ZodPlainType<ZodMiniUnion<ArrayMap<T, 'decodeZodType'>>>> {
     static factory<T extends readonly [BaseType, ...BaseType[]] = readonly [
         BaseType,
         ...BaseType[]
@@ -31,7 +32,7 @@ export type DiscriminatedUnionOptionType<K extends string> = ObjectType<ObjectTy
 export declare class DiscriminatedUnionType<K extends string = string, T extends readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[]> extends BaseType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodeZodType'>>, ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodeZodType'>>, {
     key: K;
     options: T;
-}> {
+}, ZodPlainType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'encodeZodType'>>>, ZodPlainType<ZodMiniDiscriminatedUnion<ArrayMap<T, 'decodeZodType'>>>> {
     static factory<K extends string = string, T extends readonly DiscriminatedUnionOptionType<K>[] = DiscriminatedUnionOptionType<K>[]>(key: K, ...options: T): DiscriminatedUnionType<K, T>;
 }
 export declare const union: typeof UnionType.factory;

package/package.json

@@ -34,19 +34,19 @@
   "peerDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.4"
+    "@nmtjs/common": "0.14.5"
   },
   "devDependencies": {
     "temporal-polyfill": "^0.3.0",
     "zod": "^4.0.0",
-    "@nmtjs/common": "0.14.4"
+    "@nmtjs/common": "0.14.5"
   },
   "peerDependenciesMeta": {
     "temporal-polyfill": {
       "optional": true
     }
   },
-  "version": "0.14.4",
+  "version": "0.14.5",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"