@zod-utils/core 4.0.0 → 6.0.0

package/dist/index.d.ts

@@ -70,11 +70,42 @@ type DiscriminatorKey<TSchema extends z$1.ZodType> = keyof z$1.input<TSchema> &
  */
 type DiscriminatorValue<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>> = TDiscriminatorKey extends string ? z$1.input<TSchema>[TDiscriminatorKey] & util.Literal : never;
 /**
- * Discriminator configuration for discriminated union schemas.
+ * Recursively unwraps Zod wrapper types to get the core schema type.
+ * Handles: ZodPipe (transform), ZodOptional, ZodNullable, ZodDefault
+ */
+type UnwrapZodType<T> = T extends z$1.ZodPipe<infer In, SomeType> ? UnwrapZodType<In> : T extends z$1.ZodOptional<infer Inner> ? UnwrapZodType<Inner> : T extends z$1.ZodNullable<infer Inner> ? UnwrapZodType<Inner> : T extends z$1.ZodDefault<infer Inner> ? UnwrapZodType<Inner> : T;
+/**
+ * Checks if the core (unwrapped) type is a ZodDiscriminatedUnion.
+ */
+type IsDiscriminatedUnion<T> = UnwrapZodType<T> extends z$1.ZodDiscriminatedUnion ? true : false;
+/**
+ * Conditional discriminator prop type for schemas.
+ *
+ * For discriminated unions: returns `{ discriminator: { key, value } }` (required)
+ * For non-unions: returns `{ discriminator?: never }` (prohibited)
+ *
+ * This enables type-safe props where discriminator is only required when the schema
+ * is actually a discriminated union.
+ *
+ * @example
+ * ```typescript
+ * // Use as props intersection:
+ * type Props<TSchema> = { schema: TSchema; name: string } & DiscriminatorProps<TSchema, TKey, TValue>;
+ *
+ * // For discriminated unions - discriminator is required
+ * // For regular objects - discriminator is prohibited
+ *
+ * // To extract the { key, value } object:
+ * DiscriminatorProps<Schema, Key, Value>['discriminator']
+ * ```
  */
-type Discriminator<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>> = {
-    key: TDiscriminatorKey;
-    value: TDiscriminatorValue;
+type DiscriminatorProps<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never> = IsDiscriminatedUnion<TSchema> extends true ? {
+    discriminator: {
+        key: TDiscriminatorKey;
+        value: TDiscriminatorValue;
+    };
+} : {
+    discriminator?: never;
 };
 interface FileList {
     readonly length: number;
@@ -88,15 +119,17 @@ type IsTuple<T extends ReadonlyArray<unknown>> = number extends T['length'] ? fa
 type TupleKeys<T extends ReadonlyArray<unknown>> = Exclude<keyof T, keyof unknown[]>;
 type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
 type AnyIsEqual<T1, T2> = T1 extends T2 ? IsEqual<T1, T2> extends true ? true : never : never;
-type CheckFilter<V, FilterType, Strict extends boolean> = Strict extends true ? [V] extends [FilterType] ? true : false : V extends FilterType ? true : never;
+type HasMatch<V, TFilterType> = V extends TFilterType ? true : false;
+type IsNullable<V> = null extends V ? true : undefined extends V ? true : false;
+type CheckFilter<V, TFilterType, TStrict extends boolean> = TStrict extends true ? [V] extends [TFilterType] ? true : false : true extends HasMatch<V, TFilterType> ? true : false;
 type ArrayPaths = '${number}' | `${number}`;
-type PathImpl<K extends string | number, V, TraversedTypes, FilterType = unknown, Strict extends boolean = true> = [V] extends [Primitive | BrowserNativeObject] ? CheckFilter<V, FilterType, Strict> extends true ? `${K}` : never : true extends AnyIsEqual<TraversedTypes, V> ? CheckFilter<V, FilterType, Strict> extends true ? `${K}` : never : K extends number ? (CheckFilter<V, FilterType, Strict> extends true ? ArrayPaths : never) | `${ArrayPaths}.${PathInternal<V, TraversedTypes | V, FilterType, Strict>}` : (CheckFilter<V, FilterType, Strict> extends true ? `${K}` : never) | `${K}.${PathInternal<V, TraversedTypes | V, FilterType, Strict>}`;
-type PathInternal<T, TraversedTypes = T, FilterType = unknown, Strict extends boolean = true> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes, FilterType, Strict>;
-}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes, FilterType, Strict> : {
-    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes, FilterType, Strict>;
+type PathImpl<K extends string | number, V, TraversedTypes, TFilterType = unknown, TStrict extends boolean = true> = [V] extends [Primitive | BrowserNativeObject] ? CheckFilter<V, TFilterType, TStrict> extends true ? K extends number ? ArrayPaths : `${K}` : never : true extends AnyIsEqual<TraversedTypes, V> ? CheckFilter<V, TFilterType, TStrict> extends true ? `${K}` : never : K extends number ? (CheckFilter<V, TFilterType, TStrict> extends true ? ArrayPaths : never) | `${ArrayPaths}.${PathInternal<V, TraversedTypes | V, TFilterType, TStrict>}` : (CheckFilter<V, TFilterType, TStrict> extends true ? `${K}` : never) | (unknown extends TFilterType ? `${K}.${PathInternal<V, TraversedTypes | V, TFilterType, TStrict>}` : IsNullable<V> extends true ? TStrict extends true ? never : `${K}.${PathInternal<V, TraversedTypes | V, TFilterType, TStrict>}` : `${K}.${PathInternal<V, TraversedTypes | V, TFilterType, TStrict>}`);
+type PathInternal<T, TraversedTypes = T, TFilterType = unknown, TStrict extends boolean = true> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes, TFilterType, TStrict>;
+}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes, TFilterType, TStrict> : {
+    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes, TFilterType, TStrict>;
 }[keyof T];
-type Paths<T, FilterType = unknown, Strict extends boolean = true> = PathInternal<T, T, FilterType, Strict>;
+type Paths<T, TFilterType = unknown, TStrict extends boolean = true> = PathInternal<T, T, TFilterType, TStrict>;
 /**
  * Extracts fields common to all variants in a union type.
  *
@@ -112,15 +145,6 @@ type Paths<T, FilterType = unknown, Strict extends boolean = true> = PathInterna
  * ```
  */
 type CommonFields<T> = Pick<T, keyof T>;
-/**
- * Recursively unwraps Zod wrapper types to get the core schema type.
- * Handles: ZodPipe (transform), ZodOptional, ZodNullable, ZodDefault
- */
-type UnwrapZodType<T> = T extends z$1.ZodPipe<infer In, SomeType> ? UnwrapZodType<In> : T extends z$1.ZodOptional<infer Inner> ? UnwrapZodType<Inner> : T extends z$1.ZodNullable<infer Inner> ? UnwrapZodType<Inner> : T extends z$1.ZodDefault<infer Inner> ? UnwrapZodType<Inner> : T;
-/**
- * Checks if the core (unwrapped) type is a ZodDiscriminatedUnion.
- */
-type IsDiscriminatedUnion<T> = UnwrapZodType<T> extends z$1.ZodDiscriminatedUnion ? true : false;
 /**
  * Extracts the input type from a discriminated union variant.
  *
@@ -170,24 +194,176 @@ type DiscriminatedInput<TSchema extends z$1.ZodType, TDiscriminatorKey extends D
  * ```
  */
 type ValidPaths<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true> = Paths<DiscriminatedInput<TSchema, TDiscriminatorKey, TDiscriminatorValue>, TFilterType, TStrict>;
-type InnerFieldSelector<TSchema extends z$1.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true> = TSchema extends z$1.ZodPipe<infer In> ? In extends z$1.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    name: TPath;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
-    schema: TSchema;
-    name: TPath;
-    discriminator?: never;
-} : TSchema extends z$1.ZodDiscriminatedUnion ? {
-    schema: TSchema;
-    name: TPath;
-    discriminator: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-} : {
+/**
+ * Type for props containing a Zod schema.
+ *
+ * A simple wrapper type useful for factory functions and component props
+ * that need to accept a schema parameter.
+ *
+ * @template TSchema - The Zod schema type
+ *
+ * @example
+ * Factory function accepting schema
+ * ```typescript
+ * function createFormField<TSchema extends z.ZodType>(
+ *   props: SchemaProps<TSchema>
+ * ) {
+ *   return (childProps: NameProps<TSchema>) => {
+ *     // Use props.schema and childProps.name
+ *   };
+ * }
+ * ```
+ *
+ * @example
+ * Component props with schema
+ * ```typescript
+ * type MyComponentProps<TSchema extends z.ZodType> =
+ *   SchemaProps<TSchema> & { label: string };
+ * ```
+ */
+type SchemaProps<TSchema extends z$1.ZodType> = {
     schema: TSchema;
-    name: TPath;
-    discriminator?: never;
 };
-type FieldSelector<TSchema extends z$1.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true> = InnerFieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
+/**
+ * Type for props containing a schema and optional discriminator.
+ *
+ * Combines SchemaProps and DiscriminatorProps for functions that need
+ * schema + discriminator but don't take a field name path.
+ *
+ * @template TSchema - The Zod schema type
+ * @template TDiscriminatorKey - The discriminator key for discriminated unions
+ * @template TDiscriminatorValue - The discriminator value for discriminated unions
+ *
+ * @example
+ * Function accepting schema with discriminator
+ * ```typescript
+ * function getDefaults<
+ *   TSchema extends z.ZodType,
+ *   TDiscriminatorKey extends DiscriminatorKey<TSchema>,
+ *   TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>,
+ * >(
+ *   params: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>
+ * ) {
+ *   // Use params.schema and params.discriminator
+ * }
+ * ```
+ */
+type SchemaAndDiscriminatorProps<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never> = SchemaProps<TSchema> & DiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
+/**
+ * Type for props containing a field name path.
+ *
+ * Supports discriminated union narrowing via TDiscriminatorKey/TDiscriminatorValue.
+ * The name is constrained to valid paths within the schema.
+ *
+ * @template TSchema - The Zod schema type
+ * @template TPath - The path type (must extend ValidPaths)
+ * @template TDiscriminatorKey - The discriminator key for discriminated unions
+ * @template TDiscriminatorValue - The discriminator value for discriminated unions
+ * @template TFilterType - Optional type filter for paths
+ * @template TStrict - Whether to use strict path matching
+ *
+ * @example
+ * Basic usage with object schema
+ * ```typescript
+ * const schema = z.object({ name: z.string(), age: z.number() });
+ *
+ * type Props = NameProps<typeof schema, 'name'>;
+ * // { name: 'name' }
+ * ```
+ *
+ * @example
+ * With discriminated union
+ * ```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 CreateProps = NameProps<typeof schema, 'name', 'mode', 'create'>;
+ * // { name: 'name' }
+ * ```
+ */
+type NameProps<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true> = {
+    name: ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
+};
+/**
+ * Type for props containing a field name path and discriminator.
+ *
+ * Combines `NameProps` and `DiscriminatorProps` for functions that need
+ * a field path with discriminator support but don't take a schema directly
+ * (e.g., factory-returned components where schema is already bound).
+ *
+ * @template TSchema - The Zod schema type
+ * @template TPath - The path type (must extend ValidPaths)
+ * @template TDiscriminatorKey - The discriminator key for discriminated unions
+ * @template TDiscriminatorValue - The discriminator value for discriminated unions
+ * @template TFilterType - Optional type filter for paths
+ * @template TStrict - Whether to use strict path matching
+ *
+ * @example
+ * Factory-returned component props
+ * ```typescript
+ * function createFormField<TSchema extends z.ZodType>(factoryProps: SchemaProps<TSchema>) {
+ *   return function BoundFormField<
+ *     TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue>,
+ *     TDiscriminatorKey extends DiscriminatorKey<TSchema> = never,
+ *     TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never,
+ *   >(
+ *     props: NameAndDiscriminatorProps<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue>
+ *   ) {
+ *     // props has { name, discriminator? } - schema comes from factoryProps
+ *   };
+ * }
+ * ```
+ */
+type NameAndDiscriminatorProps<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true> = NameProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> & DiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
+/**
+ * Complete field selector type combining schema, name path, and discriminator.
+ *
+ * This is the main type for selecting fields from a Zod schema with full
+ * discriminated union support. Combines:
+ * - `SchemaProps<TSchema>` - the schema prop
+ * - `NameProps<...>` - the name path prop
+ * - `DiscriminatorProps<...>` - conditional discriminator (required for unions, prohibited otherwise)
+ *
+ * @template TSchema - The Zod schema type
+ * @template TDiscriminatorKey - The discriminator key for discriminated unions
+ * @template TDiscriminatorValue - The discriminator value for discriminated unions
+ * @template TFilterType - Optional type filter for paths
+ * @template TStrict - Whether to use strict path matching
+ * @template TPath - The path type (must extend ValidPaths)
+ *
+ * @example
+ * Basic usage with object schema
+ * ```typescript
+ * const schema = z.object({ name: z.string(), age: z.number() });
+ *
+ * type Props = FieldSelectorProps<typeof schema>;
+ * // { schema: typeof schema; name: 'name' | 'age'; discriminator?: never }
+ * ```
+ *
+ * @example
+ * With discriminated union
+ * ```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 CreateProps = FieldSelectorProps<typeof schema, 'mode', 'create'>;
+ * // { schema: typeof schema; name: 'mode' | 'name'; discriminator: { key: 'mode'; value: 'create' } }
+ * ```
+ *
+ * @example
+ * With type filtering
+ * ```typescript
+ * const schema = z.object({ name: z.string(), age: z.number(), count: z.number() });
+ *
+ * type NumberFieldProps = FieldSelectorProps<typeof schema, never, never, number>;
+ * // { schema: typeof schema; name: 'age' | 'count'; discriminator?: never }
+ * ```
+ */
+type FieldSelectorProps<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true> = SchemaProps<TSchema> & NameAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
 
 /**
  * Extracts the default value from a Zod field, recursively unwrapping optional, nullable, and union layers.
@@ -320,9 +496,7 @@ declare function extractDefaultValue<T extends z.ZodType>(field: T): z.input<T>
  * @see {@link extractDefaultValue} for extracting defaults from individual fields
  * @since 0.1.0
  */
-declare function getSchemaDefaults<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>(schema: TSchema, options?: {
-    discriminator?: Discriminator<TSchema, TDiscriminatorKey, TDiscriminatorValue>;
-}): Simplify<Partial<z.input<TSchema>>>;
+declare function getSchemaDefaults<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>(params: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>): Simplify<Partial<z.input<TSchema>>>;
 
 /**
  * Recursively extracts the exact schema type from a discriminated union based on the discriminator value.
@@ -387,7 +561,7 @@ type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUn
  * @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
+ * @returns The exact matching schema option (with precise type), or `undefined` if not found or schema is not a discriminated union
  *
  * @example
  * Basic discriminated union - create/edit mode
@@ -408,16 +582,14 @@ type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUn
  * // Extract the "create" schema
  * const createSchema = extractDiscriminatedSchema({
  *   schema: userSchema,
- *   discriminatorKey: 'mode',
- *   discriminatorValue: 'create',
+ *   discriminator: { key: 'mode', value: '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',
+ *   discriminator: { key: 'mode', value: 'edit' },
  * });
  * // Result: z.object({ mode: z.literal('edit'), id: z.number(), name: z.string().optional() })
  * ```
@@ -432,8 +604,7 @@ type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUn
  *
  * const clickSchema = extractDiscriminatedSchema({
  *   schema: eventSchema,
- *   discriminatorKey: 'type',
- *   discriminatorValue: 'click',
+ *   discriminator: { key: 'type', value: 'click' },
  * });
  * // Result: z.object({ type: z.literal('click'), x: z.number(), y: z.number() })
  * ```
@@ -447,8 +618,7 @@ type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUn
  *
  * const result = extractDiscriminatedSchema({
  *   schema,
- *   discriminatorKey: 'mode',
- *   discriminatorValue: 'invalid', // doesn't match any option
+ *   discriminator: { key: 'mode', value: 'invalid' }, // doesn't match any option
  * });
  * // Result: undefined
  * ```
@@ -463,8 +633,7 @@ type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUn
  *
  * const createSchema = extractDiscriminatedSchema({
  *   schema,
- *   discriminatorKey: 'mode',
- *   discriminatorValue: 'create',
+ *   discriminator: { key: 'mode', value: 'create' },
  * });
  *
  * // Type is EXACTLY: z.object({ mode: z.literal('create'), name: z.string(), age: z.number() })
@@ -481,9 +650,7 @@ type ExtractZodUnionMember<TSchema extends z$1.ZodUnion | z$1.ZodDiscriminatedUn
  * @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;
+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, discriminator, }: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType | undefined;
 
 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;
@@ -493,7 +660,9 @@ type NavigateZod<T, Path extends string[]> = Path extends [
     ...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, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>({ schema, name, discriminator, }: FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>): (ExtractZodByPath<TSchema, TPath> & z$1.ZodType) | undefined;
+declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema> = never, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = never, TFilterType = unknown, TStrict extends boolean = true, TName extends string = string>(params: FieldSelectorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict> & {
+    name: TName;
+}): (ExtractZodByPath<TSchema, TName> & z$1.ZodType) | undefined;
 /**
  * Extends a Zod field with a transformation while preserving its metadata.
  *
@@ -514,26 +683,6 @@ declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TPath exten
  * ```
  */
 declare function extendWithMeta<T extends z$1.ZodType, R extends z$1.ZodType>(field: T, transform: (f: T) => R): R;
-/**
- * Extracts a FieldSelector from props containing schema, name, and optional discriminator.
- * Encapsulates type assertion so callers don't need eslint-disable.
- *
- * @param props - Object containing schema, name, and optional discriminator
- * @returns Properly typed FieldSelector
- *
- * @example
- * ```typescript
- * const selectorProps = toFieldSelector<TSchema, TPath, ...>(props);
- * ```
- */
-declare function toFieldSelector<TSchema extends z$1.ZodType, TPath extends ValidPaths<TSchema, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TFilterType = unknown, TStrict extends boolean = true>(props: {
-    schema: z$1.ZodType;
-    name: string;
-    discriminator?: {
-        key: string;
-        value: unknown;
-    };
-}): FieldSelector<TSchema, TPath, TDiscriminatorKey, TDiscriminatorValue, TFilterType, TStrict>;
 
 /**
  * Type representing a Zod type that has an unwrap method
@@ -562,6 +711,15 @@ type Unwrappable = {
  * @since 0.1.0
  */
 declare function canUnwrap(field: z$1.ZodTypeAny): field is z$1.ZodTypeAny & Unwrappable;
+/**
+ * Type guard that checks if a Zod field is a ZodPipe with a ZodType input.
+ *
+ * Used to safely access `field.def.in` on pipe types for unwrapping transformations.
+ *
+ * @param field - The Zod field to check
+ * @returns True if field is a ZodPipe with a ZodType input
+ */
+declare function isPipeWithZodInput(field: z$1.ZodTypeAny): field is z$1.ZodPipe<z$1.ZodType, z$1.ZodTypeAny>;
 /**
  * Attempts to strip nullish types from a union and return the single remaining type.
  *
@@ -868,4 +1026,4 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
  */
 declare function getFieldChecks<T extends z$1.ZodTypeAny>(field: T): Array<ZodUnionCheck>;
 
-export { type CommonFields, type DiscriminatedInput, type Discriminator, type DiscriminatorKey, type DiscriminatorValue, type ExtractZodByPath, type FieldSelector, type InnerFieldSelector, type IsDiscriminatedUnion, type PathImpl, type PathInternal, type Paths, type Simplify, type UnwrapZodType, type ValidPaths, type ZodUnionCheck, canUnwrap, extendWithMeta, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, toFieldSelector, tryStripNullishOnly };
+export { type CommonFields, type DiscriminatedInput, type DiscriminatorKey, type DiscriminatorProps, type DiscriminatorValue, type ExtractZodByPath, type FieldSelectorProps, type FileList, type IsDiscriminatedUnion, type NameAndDiscriminatorProps, type NameProps, type PathImpl, type PathInternal, type Paths, type SchemaAndDiscriminatorProps, type SchemaProps, type Simplify, type UnwrapZodType, type ValidPaths, type ZodUnionCheck, canUnwrap, extendWithMeta, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, isPipeWithZodInput, removeDefault, requiresValidInput, tryStripNullishOnly };

package/dist/index.js

@@ -23,6 +23,8 @@ function _interopNamespace(e) {
 var z3__namespace = /*#__PURE__*/_interopNamespace(z3);
 
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -38,27 +40,13 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-var extractDiscriminatedSchema = ({
-  schema,
-  key,
-  value
-}) => {
-  if (!(schema instanceof z3.z.ZodDiscriminatedUnion)) {
-    return void 0;
-  }
-  return schema.options.find((option) => {
-    if (option instanceof z3.z.ZodObject) {
-      const targetField = option.shape[String(key)];
-      if (!targetField) return false;
-      const parseResult = targetField.safeParse(value);
-      return parseResult.success;
-    }
-    return false;
-  });
-};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 function canUnwrap(field) {
   return "unwrap" in field && typeof field.unwrap === "function";
 }
+function isPipeWithZodInput(field) {
+  return field instanceof z3.z.ZodPipe && field.def.in instanceof z3.z.ZodType;
+}
 function tryStripNullishOnly(field) {
   if (field instanceof z3.z.ZodUnion) {
     const unionOptions = [...field.def.options];
@@ -79,6 +67,9 @@ var getPrimitiveType = (field) => {
   if (canUnwrap(field)) {
     return getPrimitiveType(field.unwrap());
   }
+  if (field instanceof z3.z.ZodDiscriminatedUnion) {
+    return field;
+  }
   if (field instanceof z3.z.ZodUnion) {
     const unwrapped = tryStripNullishOnly(field);
     if (unwrapped !== false) {
@@ -86,7 +77,7 @@ var getPrimitiveType = (field) => {
     }
     return field;
   }
-  if (field instanceof z3.z.ZodPipe && field.def.in instanceof z3.z.ZodType) {
+  if (isPipeWithZodInput(field)) {
     return getPrimitiveType(field.def.in);
   }
   return field;
@@ -124,6 +115,27 @@ function getFieldChecks(field) {
   return ((_a = primitiveType.def.checks) == null ? void 0 : _a.map((check) => check._zod.def)) || [];
 }
 
+// src/discriminatedSchema.ts
+var extractDiscriminatedSchema = ({
+  schema,
+  discriminator
+}) => {
+  const primitiveSchema = getPrimitiveType(schema);
+  if (!(primitiveSchema instanceof z3.z.ZodDiscriminatedUnion) || !discriminator) {
+    return void 0;
+  }
+  const { key, value } = discriminator;
+  return primitiveSchema.options.find((option) => {
+    if (option instanceof z3.z.ZodObject) {
+      const targetField = option.shape[String(key)];
+      if (!targetField) return false;
+      const parseResult = targetField.safeParse(value);
+      return parseResult.success;
+    }
+    return false;
+  });
+};
+
 // src/defaults.ts
 function extractDefaultValue(field) {
   if (field instanceof z3__namespace.ZodDefault) {
@@ -139,22 +151,20 @@ function extractDefaultValue(field) {
     }
     return void 0;
   }
-  if (field instanceof z3__namespace.ZodPipe && field.def.in instanceof z3__namespace.ZodType) {
+  if (isPipeWithZodInput(field)) {
     return extractDefaultValue(field.def.in);
   }
   return void 0;
 }
-function getSchemaDefaults(schema, options) {
-  const primitiveSchema = getPrimitiveType(schema);
+function getSchemaDefaults(params) {
+  const primitiveSchemaParams = __spreadProps(__spreadValues({}, params), {
+    schema: getPrimitiveType(params.schema)
+  });
   let targetSchema;
-  if (primitiveSchema instanceof z3__namespace.ZodDiscriminatedUnion) {
-    if (options == null ? void 0 : options.discriminator) {
-      targetSchema = extractDiscriminatedSchema(__spreadValues({
-        schema: primitiveSchema
-      }, options.discriminator));
-    }
-  } else if (primitiveSchema instanceof z3__namespace.ZodObject) {
-    targetSchema = primitiveSchema;
+  if (primitiveSchemaParams.schema instanceof z3__namespace.ZodDiscriminatedUnion) {
+    targetSchema = extractDiscriminatedSchema(primitiveSchemaParams);
+  } else if (primitiveSchemaParams.schema instanceof z3__namespace.ZodObject) {
+    targetSchema = primitiveSchemaParams.schema;
   }
   const defaults = {};
   if (targetSchema) {
@@ -169,24 +179,20 @@ function getSchemaDefaults(schema, options) {
   }
   return defaults;
 }
-function extractFieldFromSchema({
-  schema,
-  name,
-  discriminator
-}) {
+function extractFieldFromSchema(params) {
   let currentSchema;
-  const primitiveSchema = getPrimitiveType(schema);
-  if (primitiveSchema instanceof z3.z.ZodDiscriminatedUnion) {
-    if (discriminator) {
-      currentSchema = extractDiscriminatedSchema(__spreadValues({
-        schema: primitiveSchema
-      }, discriminator));
+  const newParams = __spreadProps(__spreadValues({}, params), {
+    schema: getPrimitiveType(params.schema)
+  });
+  if (newParams.schema instanceof z3.z.ZodDiscriminatedUnion) {
+    if (newParams.discriminator) {
+      currentSchema = extractDiscriminatedSchema(newParams);
     }
-  } else if (primitiveSchema instanceof z3.z.ZodObject) {
-    currentSchema = primitiveSchema;
+  } else if (newParams.schema instanceof z3.z.ZodObject) {
+    currentSchema = newParams.schema;
   }
   if (!currentSchema) return void 0;
-  const segments = String(name).split(".");
+  const segments = String(newParams.name).split(".");
   for (const segment of segments) {
     if (!currentSchema) return void 0;
     const unwrapped = getPrimitiveType(currentSchema);
@@ -212,10 +218,6 @@ function extendWithMeta(field, transform) {
   }
   return transformedField.meta(__spreadValues({}, meta));
 }
-function toFieldSelector(props) {
-  const { schema, name, discriminator } = props;
-  return { schema, name, discriminator };
-}
 
 exports.canUnwrap = canUnwrap;
 exports.extendWithMeta = extendWithMeta;
@@ -225,9 +227,9 @@ exports.extractFieldFromSchema = extractFieldFromSchema;
 exports.getFieldChecks = getFieldChecks;
 exports.getPrimitiveType = getPrimitiveType;
 exports.getSchemaDefaults = getSchemaDefaults;
+exports.isPipeWithZodInput = isPipeWithZodInput;
 exports.removeDefault = removeDefault;
 exports.requiresValidInput = requiresValidInput;
-exports.toFieldSelector = toFieldSelector;
 exports.tryStripNullishOnly = tryStripNullishOnly;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map