@zod-utils/core 1.2.0 → 2.0.1

package/README.md

@@ -330,7 +330,7 @@ const editSchema = extractDiscriminatedSchema({
 
 ---
 
-### `extractFieldFromSchema(schema, fieldName, discriminator?)`
+### `extractFieldFromSchema(schema, name, discriminator?)`
 
 Extract a single field from a Zod object or discriminated union schema.
 
@@ -349,7 +349,7 @@ const userSchema = z.object({
 
 const nameField = extractFieldFromSchema({
   schema: userSchema,
-  fieldName: 'name',
+  name: 'name',
 });
 // Returns: ZodString
 
@@ -370,7 +370,7 @@ const formSchema = z.discriminatedUnion('mode', [
 // Extract field from specific variant
 const idField = extractFieldFromSchema({
   schema: formSchema,
-  fieldName: 'id',
+  name: 'id',
   discriminator: {
     key: 'mode',
     value: 'edit',
@@ -381,7 +381,7 @@ const idField = extractFieldFromSchema({
 // Without discriminator on discriminated union, returns undefined
 const fieldWithoutDiscriminator = extractFieldFromSchema({
   schema: formSchema,
-  fieldName: 'name',
+  name: 'name',
 });
 // Returns: undefined (need discriminator to know which variant)
 
@@ -395,7 +395,7 @@ const transformedSchema = z
 
 const nameFromTransformed = extractFieldFromSchema({
   schema: transformedSchema,
-  fieldName: 'name',
+  name: 'name',
 });
 // Returns: ZodString (from the input type, not affected by transform)
 ```
@@ -404,6 +404,55 @@ const nameFromTransformed = extractFieldFromSchema({
 
 ---
 
+### `extendWithMeta(field, transform)`
+
+Extends a Zod field with a transformation while preserving its metadata.
+
+This is useful when you want to add validations or transformations to a field but keep the original metadata (like `translationKey`) intact.
+
+```typescript
+import { extendWithMeta } from "@zod-utils/core";
+import { z } from "zod";
+
+// Base field with metadata
+const baseField = z.string().meta({ translationKey: 'user.field.name' });
+
+// Extend with validation while keeping metadata
+const extendedField = extendWithMeta(baseField, (f) => f.min(3).max(100));
+
+extendedField.meta(); // { translationKey: 'user.field.name' }
+
+// Validation still works
+extendedField.parse('ab');     // throws - too short
+extendedField.parse('abc');    // 'abc' - valid
+```
+
+**Use case:** When building forms with shared field definitions, you may want to reuse a base field with metadata across multiple schemas while adding schema-specific validations:
+
+```typescript
+// Shared field definitions with i18n metadata
+const fields = {
+  name: z.string().meta({ translationKey: 'user.field.name' }),
+  email: z.string().email().meta({ translationKey: 'user.field.email' }),
+};
+
+// Create form uses base fields with additional constraints
+const createFormSchema = z.object({
+  name: extendWithMeta(fields.name, (f) => f.min(3).max(50)),
+  email: extendWithMeta(fields.email, (f) => f.min(5)),
+});
+
+// Edit form uses same fields with different constraints
+const editFormSchema = z.object({
+  name: extendWithMeta(fields.name, (f) => f.optional()),
+  email: fields.email, // no extension needed
+});
+```
+
+**Note:** If the original field has no metadata, the transformed field is returned as-is without calling `.meta()`.
+
+---
+
 ### `getSchemaDefaults(schema, discriminator?)`
 
 **Updated:** Now supports discriminated union schemas with the `discriminator` option.

package/dist/index.d.mts

@@ -77,6 +77,63 @@ type Discriminator<TSchema extends z$1.ZodType, TDiscriminatorKey extends Discri
     key: TDiscriminatorKey;
     value: TDiscriminatorValue;
 };
+type Primitive = string | number | boolean | null | undefined | symbol | bigint;
+type NonZeroDigit = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type PathsHint<T, Prefix extends string = ''> = T extends Primitive ? never : T extends (infer E)[] ? (Prefix extends '' ? never : Prefix) | `${Prefix}.0` | PathsHint<E, `${Prefix}.0`> : T extends object ? {
+    [K in keyof T & string]: (Prefix extends '' ? K : `${Prefix}.${K}`) | PathsHint<T[K], Prefix extends '' ? K : `${Prefix}.${K}`>;
+}[keyof T & string] : never;
+type NonZeroIndex = `${NonZeroDigit}` | `${NonZeroDigit}${number}`;
+type PathsLoose<T, Prefix extends string = ''> = T extends Primitive ? never : T extends (infer E)[] ? (Prefix extends '' ? never : Prefix) | `${Prefix}.${NonZeroIndex}` | PathsLoose<E, `${Prefix}.${NonZeroIndex}`> : T extends object ? {
+    [K in keyof T & string]: (Prefix extends '' ? K : `${Prefix}.${K}`) | PathsLoose<T[K], Prefix extends '' ? K : `${Prefix}.${K}`>;
+}[keyof T & string] : never;
+/**
+ * Generates all valid dot-notation paths for a given type.
+ * Supports nested objects and arrays with numeric indices.
+ *
+ * @example
+ * ```typescript
+ * type User = { name: string; address: { city: string } };
+ * type UserPaths = Paths<User>;
+ * // "name" | "address" | "address.city"
+ * ```
+ */
+type Paths<T> = PathsHint<T> | PathsLoose<T>;
+/**
+ * Extracts fields common to all variants in a union type.
+ *
+ * Uses `Pick<T, keyof T>` to normalize union types by extracting only
+ * the keys that exist across all union members.
+ *
+ * @example
+ * ```typescript
+ * type A = { mode: 'create'; name: string };
+ * type B = { mode: 'edit'; id: number };
+ * type Common = CommonFields<A | B>;
+ * // { mode: 'create' | 'edit' }
+ * ```
+ */
+type CommonFields<T> = Pick<T, keyof T>;
+/**
+ * Generates valid dot-notation paths for fields in a discriminated union variant.
+ *
+ * Given a schema and discriminator value, extracts all possible field paths
+ * (including nested paths) for that specific variant.
+ *
+ * @example
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string() }),
+ *   z.object({ mode: z.literal('edit'), id: z.number() }),
+ * ]);
+ *
+ * type CreatePaths = ValidPaths<typeof schema, 'mode', 'create'>;
+ * // "mode" | "name"
+ *
+ * type EditPaths = ValidPaths<typeof schema, 'mode', 'edit'>;
+ * // "mode" | "id"
+ * ```
+ */
+type ValidPaths<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>> = Paths<CommonFields<Extract<Required<z$1.input<TSchema>>, TDiscriminatorKey extends never ? z$1.input<TSchema> : TDiscriminatorValue extends never ? z$1.input<TSchema> : Simplify<Record<TDiscriminatorKey, TDiscriminatorValue>>>>>;
 
 /**
  * Extracts the default value from a Zod field, recursively unwrapping optional, nullable, and union layers.
@@ -213,11 +270,200 @@ declare function getSchemaDefaults<TSchema extends z.ZodType, TDiscriminatorKey
     discriminator?: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
 }): Simplify<Partial<z.input<TSchema>>>;
 
-declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TName extends keyof Extract<Required<z$1.input<TSchema>>, Record<TDiscriminatorKey, TDiscriminatorValue>>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, fieldName, discriminator, }: {
+/**
+ * Recursively extracts the exact schema type from a discriminated union based on the discriminator value.
+ *
+ * This advanced TypeScript utility type walks through a union's options tuple at compile-time,
+ * checking each schema against the discriminator field and value, and returns the exact matching
+ * schema type (not a union of all options).
+ *
+ * **How it works:**
+ * 1. Extracts the options tuple from the union using `infer Options`
+ * 2. Destructure into head (`First`) and tail (`Rest`) using tuple pattern matching
+ * 3. Checks if `First` is a ZodObject with the matching discriminator field and value
+ * 4. If match found, returns `First` (the exact schema type)
+ * 5. If no match, recursively processes `Rest` until a match is found or list is exhausted
+ *
+ * **Type narrowing magic:**
+ * - Input: `z.discriminatedUnion('type', [SchemaA, SchemaB, SchemaC])`
+ * - Discriminator value: `'a'` (matches SchemaA)
+ * - Output: `SchemaA` (exact type, not `SchemaA | SchemaB | SchemaC`)
+ *
+ * @template TSchema - The ZodUnion or ZodDiscriminatedUnion type
+ * @template TDiscriminatorKey - The discriminator field name (e.g., "type", "mode")
+ * @template TDiscriminatorValue - The specific discriminator value (e.g., "create", "edit")
+ * @returns The exact matching schema type, or `never` if no match found
+ *
+ * @example
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string() }),
+ *   z.object({ mode: z.literal('edit'), id: z.number() }),
+ * ]);
+ *
+ * // Exact type: z.object({ mode: z.literal('create'), name: z.string() })
+ * type CreateSchema = ExtractZodUnionMember<typeof schema, 'mode', 'create'>;
+ * ```
+ */
+type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUnion, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends z$1.input<TSchema>[TDiscriminatorKey] & util.Literal> = TSchema extends z$1.ZodUnion<infer Options> ? Options extends readonly [
+    infer First extends z$1.ZodTypeAny,
+    ...infer Rest extends z$1.ZodTypeAny[]
+] ? First extends z$1.ZodObject<infer Shape> ? TDiscriminatorKey extends keyof Shape ? Shape[TDiscriminatorKey] extends z$1.ZodLiteral<TDiscriminatorValue> | z$1.ZodDefault<z$1.ZodLiteral<TDiscriminatorValue>> ? First : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : never : never : never;
+/**
+ * Extracts a specific schema option from a discriminated union based on the discriminator field value.
+ *
+ * This function finds and returns the **exact matching schema** from a `ZodDiscriminatedUnion` by
+ * comparing the discriminator field value. It's used internally by {@link getSchemaDefaults} to
+ * extract defaults from the correct schema variant in a discriminated union.
+ *
+ * **Key feature:** Returns the **exact schema type**, not a union of all options, thanks to the
+ * {@link ExtractZodUnionMember} recursive type utility. This enables precise type narrowing at
+ * compile-time based on the discriminator value.
+ *
+ * **How it works:**
+ * 1. Iterates through all options in the discriminated union at runtime
+ * 2. For each option, validates it's a ZodObject and checks if the discriminator field matches
+ * 3. Returns the first matching schema with its exact type narrowed at compile-time
+ * 4. Returns `undefined` if no match found or if option is not a ZodObject
+ *
+ * @template TSchema - The ZodUnion or ZodDiscriminatedUnion schema type
+ * @template TDiscriminatorKey - The discriminator field name (string key of the inferred union type)
+ * @template TDiscriminatorValue - The specific discriminator value to match (literal type)
+ * @param params - Parameters object
+ * @param params.schema - The discriminated union schema to search
+ * @param params.discriminatorKey - The discriminator field name (e.g., "mode", "type")
+ * @param params.discriminatorValue - The discriminator value to match (e.g., "create", "edit")
+ * @returns The exact matching schema option (with precise type), or `undefined` if not found
+ *
+ * @example
+ * Basic discriminated union - create/edit mode
+ * ```typescript
+ * const userSchema = z.discriminatedUnion('mode', [
+ *   z.object({
+ *     mode: z.literal('create'),
+ *     name: z.string(),
+ *     age: z.number().optional(),
+ *   }),
+ *   z.object({
+ *     mode: z.literal('edit'),
+ *     id: z.number(),
+ *     name: z.string().optional(),
+ *   }),
+ * ]);
+ *
+ * // Extract the "create" schema
+ * const createSchema = extractDiscriminatedSchema({
+ *   schema: userSchema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'create',
+ * });
+ * // Result: z.object({ mode: z.literal('create'), name: z.string(), age: z.number().optional() })
+ *
+ * // Extract the "edit" schema
+ * const editSchema = extractDiscriminatedSchema({
+ *   schema: userSchema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'edit',
+ * });
+ * // Result: z.object({ mode: z.literal('edit'), id: z.number(), name: z.string().optional() })
+ * ```
+ *
+ * @example
+ * Type-based discrimination
+ * ```typescript
+ * const eventSchema = z.discriminatedUnion('type', [
+ *   z.object({ type: z.literal('click'), x: z.number(), y: z.number() }),
+ *   z.object({ type: z.literal('keypress'), key: z.string() }),
+ * ]);
+ *
+ * const clickSchema = extractDiscriminatedSchema({
+ *   schema: eventSchema,
+ *   discriminatorKey: 'type',
+ *   discriminatorValue: 'click',
+ * });
+ * // Result: z.object({ type: z.literal('click'), x: z.number(), y: z.number() })
+ * ```
+ *
+ * @example
+ * Invalid discriminator value
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string() }),
+ * ]);
+ *
+ * const result = extractDiscriminatedSchema({
+ *   schema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'invalid', // doesn't match any option
+ * });
+ * // Result: undefined
+ * ```
+ *
+ * @example
+ * Type narrowing demonstration
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string(), age: z.number() }),
+ *   z.object({ mode: z.literal('edit'), id: z.number(), bio: z.string() }),
+ * ]);
+ *
+ * const createSchema = extractDiscriminatedSchema({
+ *   schema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'create',
+ * });
+ *
+ * // Type is EXACTLY: z.object({ mode: z.literal('create'), name: z.string(), age: z.number() })
+ * // NOT: z.object({ mode: ..., ... }) | z.object({ mode: ..., ... }) | undefined
+ *
+ * if (createSchema) {
+ *   createSchema.shape.age;  // ✅ TypeScript knows 'age' exists
+ *   createSchema.shape.name; // ✅ TypeScript knows 'name' exists
+ *   // createSchema.shape.id;   // ❌ TypeScript error: 'id' doesn't exist on 'create' schema
+ * }
+ * ```
+ *
+ * @see {@link getSchemaDefaults} for usage with discriminated unions
+ * @see {@link ExtractZodUnionMember} for the type-level extraction logic
+ * @since 0.6.0
+ */
+declare const extractDiscriminatedSchema: <TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, ReturnType extends TSchema extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TSchema, TDiscriminatorKey, TDiscriminatorValue> : never>({ schema, key, value, }: {
+    schema: TSchema;
+} & Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType;
+
+type Split<S extends string> = S extends `${infer Head}.${infer Tail}` ? [Head, ...Split<Tail>] : [S];
+type IsNumeric<S extends string> = S extends `${number}` ? true : false;
+type Unwrap<T> = T extends z$1.ZodOptional<infer U> ? Unwrap<U> : T extends z$1.ZodNullable<infer U> ? Unwrap<U> : T extends z$1.ZodDefault<infer U> ? Unwrap<U> : T;
+type NavigateZod<T, Path extends string[]> = Path extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? Unwrap<T> extends z$1.ZodObject<infer Shape> ? First extends keyof Shape ? Rest extends [] ? Shape[First] : NavigateZod<Shape[First], Rest> : never : Unwrap<T> extends z$1.ZodArray<infer Element> ? IsNumeric<First> extends true ? Rest extends [] ? Element : NavigateZod<Element, Rest> : never : never : T;
+type ExtractZodByPath<Schema, Path extends string> = NavigateZod<Schema, Split<Path>>;
+declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>({ schema, name, discriminator, }: {
     schema: TSchema;
-    fieldName: TName;
+    name: TPath;
     discriminator?: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-}): z$1.ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+}): (ExtractZodByPath<TSchema, TPath> & z$1.ZodType) | undefined;
+/**
+ * Extends a Zod field with a transformation while preserving its metadata.
+ *
+ * This is useful when you want to add validations or transformations to a field
+ * but keep the original metadata (like translationKey) intact.
+ *
+ * @param field - The original Zod field
+ * @param transform - A function that transforms the field
+ * @returns The transformed field with preserved metadata
+ *
+ * @example
+ * ```typescript
+ * const baseField = z.string().meta({ translationKey: 'user.field.name' });
+ *
+ * // Add min/max validation while keeping the translationKey
+ * const extendedField = extendWithMeta(baseField, (f) => f.min(3).max(100));
+ * extendedField.meta(); // { translationKey: 'user.field.name' }
+ * ```
+ */
+declare function extendWithMeta<T extends z$1.ZodType, R extends z$1.ZodType>(field: T, transform: (f: T) => R): R;
 
 /**
  * Type representing a Zod type that has an unwrap method
@@ -551,165 +797,5 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
  * @since 0.4.0
  */
 declare function getFieldChecks<T extends z$1.ZodTypeAny>(field: T): Array<ZodUnionCheck>;
-/**
- * Recursively extracts the exact schema type from a discriminated union based on the discriminator value.
- *
- * This advanced TypeScript utility type walks through a union's options tuple at compile-time,
- * checking each schema against the discriminator field and value, and returns the exact matching
- * schema type (not a union of all options).
- *
- * **How it works:**
- * 1. Extracts the options tuple from the union using `infer Options`
- * 2. Destructure into head (`First`) and tail (`Rest`) using tuple pattern matching
- * 3. Checks if `First` is a ZodObject with the matching discriminator field and value
- * 4. If match found, returns `First` (the exact schema type)
- * 5. If no match, recursively processes `Rest` until a match is found or list is exhausted
- *
- * **Type narrowing magic:**
- * - Input: `z.discriminatedUnion('type', [SchemaA, SchemaB, SchemaC])`
- * - Discriminator value: `'a'` (matches SchemaA)
- * - Output: `SchemaA` (exact type, not `SchemaA | SchemaB | SchemaC`)
- *
- * @template TSchema - The ZodUnion or ZodDiscriminatedUnion type
- * @template TDiscriminatorKey - The discriminator field name (e.g., "type", "mode")
- * @template TDiscriminatorValue - The specific discriminator value (e.g., "create", "edit")
- * @returns The exact matching schema type, or `never` if no match found
- *
- * @example
- * ```typescript
- * const schema = z.discriminatedUnion('mode', [
- *   z.object({ mode: z.literal('create'), name: z.string() }),
- *   z.object({ mode: z.literal('edit'), id: z.number() }),
- * ]);
- *
- * // Exact type: z.object({ mode: z.literal('create'), name: z.string() })
- * type CreateSchema = ExtractZodUnionMember<typeof schema, 'mode', 'create'>;
- * ```
- */
-type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUnion, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends z$1.input<TSchema>[TDiscriminatorKey] & util.Literal> = TSchema extends z$1.ZodUnion<infer Options> ? Options extends readonly [
-    infer First extends z$1.ZodTypeAny,
-    ...infer Rest extends z$1.ZodTypeAny[]
-] ? First extends z$1.ZodObject<infer Shape> ? TDiscriminatorKey extends keyof Shape ? Shape[TDiscriminatorKey] extends z$1.ZodLiteral<TDiscriminatorValue> | z$1.ZodDefault<z$1.ZodLiteral<TDiscriminatorValue>> ? First : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionInput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z$1.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : never : never : never;
-/**
- * Extracts a specific schema option from a discriminated union based on the discriminator field value.
- *
- * This function finds and returns the **exact matching schema** from a `ZodDiscriminatedUnion` by
- * comparing the discriminator field value. It's used internally by {@link getSchemaDefaults} to
- * extract defaults from the correct schema variant in a discriminated union.
- *
- * **Key feature:** Returns the **exact schema type**, not a union of all options, thanks to the
- * {@link ExtractZodUnionMember} recursive type utility. This enables precise type narrowing at
- * compile-time based on the discriminator value.
- *
- * **How it works:**
- * 1. Iterates through all options in the discriminated union at runtime
- * 2. For each option, validates it's a ZodObject and checks if the discriminator field matches
- * 3. Returns the first matching schema with its exact type narrowed at compile-time
- * 4. Returns `undefined` if no match found or if option is not a ZodObject
- *
- * @template TSchema - The ZodUnion or ZodDiscriminatedUnion schema type
- * @template TDiscriminatorKey - The discriminator field name (string key of the inferred union type)
- * @template TDiscriminatorValue - The specific discriminator value to match (literal type)
- * @param params - Parameters object
- * @param params.schema - The discriminated union schema to search
- * @param params.discriminatorKey - The discriminator field name (e.g., "mode", "type")
- * @param params.discriminatorValue - The discriminator value to match (e.g., "create", "edit")
- * @returns The exact matching schema option (with precise type), or `undefined` if not found
- *
- * @example
- * Basic discriminated union - create/edit mode
- * ```typescript
- * const userSchema = z.discriminatedUnion('mode', [
- *   z.object({
- *     mode: z.literal('create'),
- *     name: z.string(),
- *     age: z.number().optional(),
- *   }),
- *   z.object({
- *     mode: z.literal('edit'),
- *     id: z.number(),
- *     name: z.string().optional(),
- *   }),
- * ]);
- *
- * // Extract the "create" schema
- * const createSchema = extractDiscriminatedSchema({
- *   schema: userSchema,
- *   discriminatorKey: 'mode',
- *   discriminatorValue: 'create',
- * });
- * // Result: z.object({ mode: z.literal('create'), name: z.string(), age: z.number().optional() })
- *
- * // Extract the "edit" schema
- * const editSchema = extractDiscriminatedSchema({
- *   schema: userSchema,
- *   discriminatorKey: 'mode',
- *   discriminatorValue: 'edit',
- * });
- * // Result: z.object({ mode: z.literal('edit'), id: z.number(), name: z.string().optional() })
- * ```
- *
- * @example
- * Type-based discrimination
- * ```typescript
- * const eventSchema = z.discriminatedUnion('type', [
- *   z.object({ type: z.literal('click'), x: z.number(), y: z.number() }),
- *   z.object({ type: z.literal('keypress'), key: z.string() }),
- * ]);
- *
- * const clickSchema = extractDiscriminatedSchema({
- *   schema: eventSchema,
- *   discriminatorKey: 'type',
- *   discriminatorValue: 'click',
- * });
- * // Result: z.object({ type: z.literal('click'), x: z.number(), y: z.number() })
- * ```
- *
- * @example
- * Invalid discriminator value
- * ```typescript
- * const schema = z.discriminatedUnion('mode', [
- *   z.object({ mode: z.literal('create'), name: z.string() }),
- * ]);
- *
- * const result = extractDiscriminatedSchema({
- *   schema,
- *   discriminatorKey: 'mode',
- *   discriminatorValue: 'invalid', // doesn't match any option
- * });
- * // Result: undefined
- * ```
- *
- * @example
- * Type narrowing demonstration
- * ```typescript
- * const schema = z.discriminatedUnion('mode', [
- *   z.object({ mode: z.literal('create'), name: z.string(), age: z.number() }),
- *   z.object({ mode: z.literal('edit'), id: z.number(), bio: z.string() }),
- * ]);
- *
- * const createSchema = extractDiscriminatedSchema({
- *   schema,
- *   discriminatorKey: 'mode',
- *   discriminatorValue: 'create',
- * });
- *
- * // Type is EXACTLY: z.object({ mode: z.literal('create'), name: z.string(), age: z.number() })
- * // NOT: z.object({ mode: ..., ... }) | z.object({ mode: ..., ... }) | undefined
- *
- * if (createSchema) {
- *   createSchema.shape.age;  // ✅ TypeScript knows 'age' exists
- *   createSchema.shape.name; // ✅ TypeScript knows 'name' exists
- *   // createSchema.shape.id;   // ❌ TypeScript error: 'id' doesn't exist on 'create' schema
- * }
- * ```
- *
- * @see {@link getSchemaDefaults} for usage with discriminated unions
- * @see {@link ExtractZodUnionMember} for the type-level extraction logic
- * @since 0.6.0
- */
-declare const extractDiscriminatedSchema: <TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, ReturnType extends TSchema extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TSchema, TDiscriminatorKey, TDiscriminatorValue> : never>({ schema, key, value, }: {
-    schema: TSchema;
-} & Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType;
 
-export { type Discriminator, type DiscriminatorKey, type DiscriminatorValue, type Simplify, type ZodUnionCheck, canUnwrap, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, tryStripNullishOnly };
+export { type CommonFields, type Discriminator, type DiscriminatorKey, type DiscriminatorValue, type ExtractZodByPath, type Paths, type Simplify, type ValidPaths, type ZodUnionCheck, canUnwrap, extendWithMeta, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, tryStripNullishOnly };