@xylabs/zod 5.0.50 → 5.0.52

package/dist/neutral/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/zodAsFactory.ts","../../src/zodIsFactory.ts","../../src/zodToFactory.ts","../../src/zodAllFactory.ts","../../src/zodAsAsyncFactory.ts","../../src/zodToAsyncFactory.ts"],"sourcesContent":["import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nexport function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  function asFunc<T>(value: T): (T & TZod) | undefined\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function asFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    const result = zod.safeParse(value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n        default: {\n          assertConfig = true\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n","import type z from 'zod'\n\nexport function zodIsFactory<TZod>(zod: z.ZodType<TZod>) {\n  return <T>(value: T): value is T & TZod => zod.safeParse(value).success\n}\n","import { isDefined } from '@xylabs/typeof'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsFactory } from './zodAsFactory.ts'\n\nexport function zodToFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  const as = zodAsFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): (T & TZod) | undefined\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function toFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    if (isDefined(assert)) {\n      return as(value, assert)\n    }\n    return as(value)\n  }\n  return toFunc\n}\n","import type z from 'zod'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\nimport { zodIsFactory } from './zodIsFactory.ts'\nimport { zodToFactory } from './zodToFactory.ts'\n\n/** @alpha */\nexport type AllZodFactories<TType, TName extends string> = {\n  [K in `is${TName}`]: ReturnType<typeof zodIsFactory<TType>>\n} & {\n  [K in `as${TName}`]: ReturnType<typeof zodAsFactory<TType>>\n} & {\n  [K in `to${TName}`]: ReturnType<typeof zodToFactory<TType>>\n}\n\n/** @alpha */\nexport function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName) {\n  return {\n    [`is${name}`]: zodIsFactory<T>(zod),\n    [`as${name}`]: zodAsFactory<T>(zod, `as${name}`),\n    [`to${name}`]: zodToFactory<T>(zod, `to${name}`),\n  }\n}\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nexport function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  function asFunc<T>(value: T): Promise<(T & TZod) | undefined>\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>\n  async function asFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {\n    const result = await zod.safeParseAsync(value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n        default: {\n          assertConfig = true\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n","import { isDefined } from '@xylabs/typeof'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsAsyncFactory } from './zodAsAsyncFactory.ts'\n\nexport function zodToAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {\n  const as = zodAsAsyncFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): Promise<(T & TZod) | undefined>\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>\n  async function toFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {\n    if (isDefined(assert)) {\n      return await as(value, assert)\n    }\n    return await as(value)\n  }\n  return toFunc\n}\n"],"mappings":"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","names":["assertError","isDefined","isDefined"]}
+{"version":3,"sources":["../../src/zodAsFactory.ts","../../src/zodIsFactory.ts","../../src/zodToFactory.ts","../../src/zodAllFactory.ts","../../src/zodAsAsyncFactory.ts","../../src/zodToAsyncFactory.ts"],"sourcesContent":["import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nexport function zodAsFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {\n  function asFunc<T>(value: T): (T & z.output<TZod>) | undefined\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): (T & z.output<TZod>)\n  function asFunc<T>(value: T, assert?: ZodFactoryConfig): (T & z.output<TZod>) | undefined {\n    const result = zod.safeParse(value)\n    if (result.success) {\n      return value as (T & z.output<TZod>)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n        default: {\n          assertConfig = true\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n","import type z from 'zod'\n\nexport function zodIsFactory<TZod extends z.ZodTypeAny>(zod: TZod) {\n  return <T>(value: T): value is T & z.output<TZod> => zod.safeParse(value).success\n}\n","import { isDefined } from '@xylabs/typeof'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsFactory } from './zodAsFactory.ts'\n\nexport function zodToFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {\n  const as = zodAsFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): (T & z.output<TZod>) | undefined\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): (T & z.output<TZod>)\n  function toFunc<T>(value: T, assert?: ZodFactoryConfig): (T & z.output<TZod>) | undefined {\n    if (isDefined(assert)) {\n      return as(value, assert)\n    }\n    return as(value)\n  }\n  return toFunc\n}\n","import type z from 'zod'\n\nimport { zodAsFactory } from './zodAsFactory.ts'\nimport { zodIsFactory } from './zodIsFactory.ts'\nimport { zodToFactory } from './zodToFactory.ts'\n\n/** @alpha */\nexport type AllZodFactories<TType extends z.ZodTypeAny, TName extends string> = {\n  [K in `is${TName}`]: ReturnType<typeof zodIsFactory<TType>>\n} & {\n  [K in `as${TName}`]: ReturnType<typeof zodAsFactory<TType>>\n} & {\n  [K in `to${TName}`]: ReturnType<typeof zodToFactory<TType>>\n}\n\n/** @alpha */\nexport function zodAllFactory<TType extends z.ZodTypeAny, TName extends string>(zod: TType, name: TName) {\n  return {\n    [`is${name}`]: zodIsFactory<TType>(zod),\n    [`as${name}`]: zodAsFactory<TType>(zod, `as${name}`),\n    [`to${name}`]: zodToFactory<TType>(zod, `to${name}`),\n  }\n}\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nexport function zodAsAsyncFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {\n  function asFunc<T>(value: T): Promise<(T & z.output<TZod>) | undefined>\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & z.output<TZod>)>\n  async function asFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & z.output<TZod>) | undefined> {\n    const result = await zod.safeParseAsync(value)\n    if (result.success) {\n      return value as (T & z.output<TZod>)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${value}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${value}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message)\n          break\n        }\n        default: {\n          assertConfig = true\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n","import { isDefined } from '@xylabs/typeof'\nimport type z from 'zod'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsAsyncFactory } from './zodAsAsyncFactory.ts'\n\nexport function zodToAsyncFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {\n  const as = zodAsAsyncFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): Promise<(T & z.output<TZod>) | undefined>\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & z.output<TZod>)>\n  async function toFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & z.output<TZod>) | undefined> {\n    if (isDefined(assert)) {\n      return await as(value, assert)\n    }\n    return await as(value)\n  }\n  return toFunc\n}\n"],"mappings":"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","names":["assertError","isDefined","isDefined"]}

package/dist/neutral/zodAllFactory.d.ts

@@ -3,7 +3,7 @@ import { zodAsFactory } from './zodAsFactory.ts';
 import { zodIsFactory } from './zodIsFactory.ts';
 import { zodToFactory } from './zodToFactory.ts';
 /** @alpha */
-export type AllZodFactories<TType, TName extends string> = {
+export type AllZodFactories<TType extends z.ZodTypeAny, TName extends string> = {
     [K in `is${TName}`]: ReturnType<typeof zodIsFactory<TType>>;
 } & {
     [K in `as${TName}`]: ReturnType<typeof zodAsFactory<TType>>;
@@ -11,10 +11,10 @@ export type AllZodFactories<TType, TName extends string> = {
     [K in `to${TName}`]: ReturnType<typeof zodToFactory<TType>>;
 };
 /** @alpha */
-export declare function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName): {
+export declare function zodAllFactory<TType extends z.ZodTypeAny, TName extends string>(zod: TType, name: TName): {
     [x: string]: {
-        <T_1>(value: T_1): (T_1 & T) | undefined;
-        <T_1>(value: T_1, assert: import("./Config.ts").ZodFactoryConfig): T_1 & T;
+        <T>(value: T): (T & z.z.core.output<TType>) | undefined;
+        <T>(value: T, assert: import("./Config.ts").ZodFactoryConfig): T & z.z.core.output<TType>;
     };
 };
 //# sourceMappingURL=zodAllFactory.d.ts.map

package/dist/neutral/zodAllFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodAllFactory.d.ts","sourceRoot":"","sources":["../../src/zodAllFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,aAAa;AACb,MAAM,MAAM,eAAe,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,IAAI;KACxD,CAAC,IAAI,KAAK,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;CAC5D,GAAG;KACD,CAAC,IAAI,KAAK,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;CAC5D,GAAG;KACD,CAAC,IAAI,KAAK,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;CAC5D,CAAA;AAED,aAAa;AACb,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK;;;;;EAMpF"}
+{"version":3,"file":"zodAllFactory.d.ts","sourceRoot":"","sources":["../../src/zodAllFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,aAAa;AACb,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,CAAC,CAAC,UAAU,EAAE,KAAK,SAAS,MAAM,IAAI;KAC7E,CAAC,IAAI,KAAK,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;CAC5D,GAAG;KACD,CAAC,IAAI,KAAK,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;CAC5D,GAAG;KACD,CAAC,IAAI,KAAK,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;CAC5D,CAAA;AAED,aAAa;AACb,wBAAgB,aAAa,CAAC,KAAK,SAAS,CAAC,CAAC,UAAU,EAAE,KAAK,SAAS,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK;;;;;EAMtG"}

package/dist/neutral/zodAsAsyncFactory.d.ts

@@ -1,7 +1,7 @@
 import type z from 'zod';
 import type { ZodFactoryConfig } from './Config.ts';
-export declare function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
-    <T>(value: T): Promise<(T & TZod) | undefined>;
-    <T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>;
+export declare function zodAsAsyncFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string): {
+    <T>(value: T): Promise<(T & z.output<TZod>) | undefined>;
+    <T>(value: T, assert: ZodFactoryConfig): Promise<(T & z.output<TZod>)>;
 };
 //# sourceMappingURL=zodAsAsyncFactory.d.ts.map

package/dist/neutral/zodAsAsyncFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodAsAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsAsyncFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACxD,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;KAC7C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;EAkC5E"}
+{"version":3,"file":"zodAsAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsAsyncFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,wBAAgB,iBAAiB,CAAC,IAAI,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM;KAClE,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;KACvD,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;EAkCtF"}

package/dist/neutral/zodAsFactory.d.ts

@@ -1,7 +1,7 @@
 import type z from 'zod';
 import type { ZodFactoryConfig } from './Config.ts';
-export declare function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
-    <T>(value: T): (T & TZod) | undefined;
-    <T>(value: T, assert: ZodFactoryConfig): (T & TZod);
+export declare function zodAsFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string): {
+    <T>(value: T): (T & z.output<TZod>) | undefined;
+    <T>(value: T, assert: ZodFactoryConfig): (T & z.output<TZod>);
 };
 //# sourceMappingURL=zodAsFactory.d.ts.map

package/dist/neutral/zodAsFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodAsFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KACnD,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS;KACpC,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;EAkCnE"}
+{"version":3,"file":"zodAsFactory.d.ts","sourceRoot":"","sources":["../../src/zodAsFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,wBAAgB,YAAY,CAAC,IAAI,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM;KAC7D,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS;KAC9C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;EAkC7E"}

package/dist/neutral/zodIsFactory.d.ts

@@ -1,3 +1,3 @@
 import type z from 'zod';
-export declare function zodIsFactory<TZod>(zod: z.ZodType<TZod>): <T>(value: T) => value is T & TZod;
+export declare function zodIsFactory<TZod extends z.ZodTypeAny>(zod: TZod): <T>(value: T) => value is T & z.output<TZod>;
 //# sourceMappingURL=zodIsFactory.d.ts.map

package/dist/neutral/zodIsFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodIsFactory.d.ts","sourceRoot":"","sources":["../../src/zodIsFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,IAC7C,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CACxC"}
+{"version":3,"file":"zodIsFactory.d.ts","sourceRoot":"","sources":["../../src/zodIsFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,wBAAgB,YAAY,CAAC,IAAI,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,IACvD,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAClD"}

package/dist/neutral/zodToAsyncFactory.d.ts

@@ -1,7 +1,7 @@
 import type z from 'zod';
 import type { ZodFactoryConfig } from './Config.ts';
-export declare function zodToAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
-    <T>(value: T): Promise<(T & TZod) | undefined>;
-    <T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>;
+export declare function zodToAsyncFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string): {
+    <T>(value: T): Promise<(T & z.output<TZod>) | undefined>;
+    <T>(value: T, assert: ZodFactoryConfig): Promise<(T & z.output<TZod>)>;
 };
 //# sourceMappingURL=zodToAsyncFactory.d.ts.map

package/dist/neutral/zodToAsyncFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodToAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodToAsyncFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KAExD,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;KAC7C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;EAQ5E"}
+{"version":3,"file":"zodToAsyncFactory.d.ts","sourceRoot":"","sources":["../../src/zodToAsyncFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD,wBAAgB,iBAAiB,CAAC,IAAI,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM;KAElE,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;KACvD,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;EAQtF"}

package/dist/neutral/zodToFactory.d.ts

@@ -1,7 +1,7 @@
 import type z from 'zod';
 import type { ZodFactoryConfig } from './Config.ts';
-export declare function zodToFactory<TZod>(zod: z.ZodType<TZod>, name: string): {
-    <T>(value: T): (T & TZod) | undefined;
-    <T>(value: T, assert: ZodFactoryConfig): (T & TZod);
+export declare function zodToFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string): {
+    <T>(value: T): (T & z.output<TZod>) | undefined;
+    <T>(value: T, assert: ZodFactoryConfig): (T & z.output<TZod>);
 };
 //# sourceMappingURL=zodToFactory.d.ts.map

package/dist/neutral/zodToFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zodToFactory.d.ts","sourceRoot":"","sources":["../../src/zodToFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM;KAEnD,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS;KACpC,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;EAQnE"}
+{"version":3,"file":"zodToFactory.d.ts","sourceRoot":"","sources":["../../src/zodToFactory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGnD,wBAAgB,YAAY,CAAC,IAAI,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM;KAE7D,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS;KAC9C,CAAC,SAAS,CAAC,UAAU,gBAAgB,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;EAQ7E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/zod",
-  "version": "5.0.50",
+  "version": "5.0.52",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -38,15 +38,15 @@
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/error": "~5.0.50",
-    "@xylabs/typeof": "~5.0.50",
+    "@xylabs/error": "~5.0.52",
+    "@xylabs/typeof": "~5.0.52",
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "~7.2.8",
-    "@xylabs/tsconfig": "~7.2.8",
+    "@xylabs/ts-scripts-yarn3": "~7.2.32",
+    "@xylabs/tsconfig": "~7.2.32",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.15"
+    "vitest": "~4.0.16"
   },
   "publishConfig": {
     "access": "public"

package/src/zodAllFactory.ts

@@ -5,7 +5,7 @@ import { zodIsFactory } from './zodIsFactory.ts'
 import { zodToFactory } from './zodToFactory.ts'
 
 /** @alpha */
-export type AllZodFactories<TType, TName extends string> = {
+export type AllZodFactories<TType extends z.ZodTypeAny, TName extends string> = {
   [K in `is${TName}`]: ReturnType<typeof zodIsFactory<TType>>
 } & {
   [K in `as${TName}`]: ReturnType<typeof zodAsFactory<TType>>
@@ -14,10 +14,10 @@ export type AllZodFactories<TType, TName extends string> = {
 }
 
 /** @alpha */
-export function zodAllFactory<T, TName extends string>(zod: z.ZodType<T>, name: TName) {
+export function zodAllFactory<TType extends z.ZodTypeAny, TName extends string>(zod: TType, name: TName) {
   return {
-    [`is${name}`]: zodIsFactory<T>(zod),
-    [`as${name}`]: zodAsFactory<T>(zod, `as${name}`),
-    [`to${name}`]: zodToFactory<T>(zod, `to${name}`),
+    [`is${name}`]: zodIsFactory<TType>(zod),
+    [`as${name}`]: zodAsFactory<TType>(zod, `as${name}`),
+    [`to${name}`]: zodToFactory<TType>(zod, `to${name}`),
   }
 }

package/src/zodAsAsyncFactory.ts

@@ -4,13 +4,13 @@ import type z from 'zod'
 
 import type { ZodFactoryConfig } from './Config.ts'
 
-export function zodAsAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {
-  function asFunc<T>(value: T): Promise<(T & TZod) | undefined>
-  function asFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>
-  async function asFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {
+export function zodAsAsyncFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {
+  function asFunc<T>(value: T): Promise<(T & z.output<TZod>) | undefined>
+  function asFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & z.output<TZod>)>
+  async function asFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & z.output<TZod>) | undefined> {
     const result = await zod.safeParseAsync(value)
     if (result.success) {
-      return value as (T & TZod)
+      return value as (T & z.output<TZod>)
     }
     if (assert !== undefined) {
       let assertConfig: AssertConfig

package/src/zodAsFactory.ts

@@ -4,13 +4,13 @@ import type z from 'zod'
 
 import type { ZodFactoryConfig } from './Config.ts'
 
-export function zodAsFactory<TZod>(zod: z.ZodType<TZod>, name: string) {
-  function asFunc<T>(value: T): (T & TZod) | undefined
-  function asFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)
-  function asFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {
+export function zodAsFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {
+  function asFunc<T>(value: T): (T & z.output<TZod>) | undefined
+  function asFunc<T>(value: T, assert: ZodFactoryConfig): (T & z.output<TZod>)
+  function asFunc<T>(value: T, assert?: ZodFactoryConfig): (T & z.output<TZod>) | undefined {
     const result = zod.safeParse(value)
     if (result.success) {
-      return value as (T & TZod)
+      return value as (T & z.output<TZod>)
     }
     if (assert !== undefined) {
       let assertConfig: AssertConfig

package/src/zodIsFactory.ts

@@ -1,5 +1,5 @@
 import type z from 'zod'
 
-export function zodIsFactory<TZod>(zod: z.ZodType<TZod>) {
-  return <T>(value: T): value is T & TZod => zod.safeParse(value).success
+export function zodIsFactory<TZod extends z.ZodTypeAny>(zod: TZod) {
+  return <T>(value: T): value is T & z.output<TZod> => zod.safeParse(value).success
 }

package/src/zodToAsyncFactory.ts

@@ -4,11 +4,11 @@ import type z from 'zod'
 import type { ZodFactoryConfig } from './Config.ts'
 import { zodAsAsyncFactory } from './zodAsAsyncFactory.ts'
 
-export function zodToAsyncFactory<TZod>(zod: z.ZodType<TZod>, name: string) {
+export function zodToAsyncFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {
   const as = zodAsAsyncFactory<TZod>(zod, name)
-  function toFunc<T>(value: T): Promise<(T & TZod) | undefined>
-  function toFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & TZod)>
-  async function toFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & TZod) | undefined> {
+  function toFunc<T>(value: T): Promise<(T & z.output<TZod>) | undefined>
+  function toFunc<T>(value: T, assert: ZodFactoryConfig): Promise<(T & z.output<TZod>)>
+  async function toFunc<T>(value: T, assert?: ZodFactoryConfig): Promise<(T & z.output<TZod>) | undefined> {
     if (isDefined(assert)) {
       return await as(value, assert)
     }

package/src/zodToFactory.ts

@@ -4,11 +4,11 @@ import type z from 'zod'
 import type { ZodFactoryConfig } from './Config.ts'
 import { zodAsFactory } from './zodAsFactory.ts'
 
-export function zodToFactory<TZod>(zod: z.ZodType<TZod>, name: string) {
+export function zodToFactory<TZod extends z.ZodTypeAny>(zod: TZod, name: string) {
   const as = zodAsFactory<TZod>(zod, name)
-  function toFunc<T>(value: T): (T & TZod) | undefined
-  function toFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)
-  function toFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {
+  function toFunc<T>(value: T): (T & z.output<TZod>) | undefined
+  function toFunc<T>(value: T, assert: ZodFactoryConfig): (T & z.output<TZod>)
+  function toFunc<T>(value: T, assert?: ZodFactoryConfig): (T & z.output<TZod>) | undefined {
     if (isDefined(assert)) {
       return as(value, assert)
     }