@zod-utils/core 7.0.1 → 7.2.0

package/README.md

@@ -23,6 +23,8 @@ npm install @zod-utils/core zod
 ## Features
 
 - **Extract defaults** - Get default values from Zod schemas
+- **Extract meta** - Get `.meta()` property values from schema fields
+- **Merge defaults with meta** - Combine defaults and meta into a single result
 - **Check validation requirements** - Determine if fields will error on empty input
 - **Extract validation checks** - Get all validation constraints (min/max, formats, patterns, etc.)
 - **Schema utilities** - Unwrap and manipulate schema types
@@ -83,6 +85,9 @@ npm install @zod-utils/core zod
       - [With Transforms](#with-transforms-2)
     - [`extendWithMeta(field, transform)`](#extendwithmetafield-transform)
       - [Use Case: Shared Field Definitions with i18n](#use-case-shared-field-definitions-with-i18n)
+    - [`extractMeta(field, metaKey)`](#extractmetafield-metakey)
+    - [`getSchemaMeta(params, metaKey)`](#getschemametaparams-metakey)
+    - [`getMergedSchemaDefaults(params, metaKey)`](#getmergedschemadefaultsparams-metakey)
     - [`toFieldSelector(props)`](#tofieldselectorprops)
   - [Type Utilities](#type-utilities)
     - [`Simplify<T>`](#simplifyt)
@@ -690,6 +695,32 @@ getFieldChecks(
 // [{ check: 'min_length', ... }, { check: 'max_length', ... }]
 ```
 
+#### Union Types
+
+```typescript
+// Collects checks from all union options
+getFieldChecks(z.union([z.string().min(3), z.string().email()]));
+// [{ check: 'min_length', minimum: 3, ... }, { check: 'string_format', format: 'email', ... }]
+
+// Works with nullable/optional unions
+getFieldChecks(z.string().min(5).nullable());
+// [{ check: 'min_length', minimum: 5, ... }]
+```
+
+#### Format Types (Zod v4)
+
+```typescript
+// Format types (ZodURL, ZodEmail, ZodUUID, etc.) are fully supported
+getFieldChecks(z.email());
+// [{ check: 'string_format', format: 'email', ... }]
+
+getFieldChecks(z.url());
+// [{ check: 'string_format', format: 'url', ... }]
+
+getFieldChecks(z.uuid());
+// [{ check: 'string_format', format: 'uuid', ... }]
+```
+
 #### No Constraints
 
 ```typescript
@@ -978,6 +1009,145 @@ const editFormSchema = z.object({
 
 ---
 
+### `extractMeta(field, metaKey)`
+
+Extract the value of a specific meta key from a Zod field. Recursively unwraps optional, nullable, default, transform, and union layers.
+
+For `ZodObject` fields: if the object's own meta contains the target key, returns that value directly. Otherwise, recurses into shape children and returns a nested record.
+
+```typescript
+import { extractMeta } from "@zod-utils/core";
+import { z } from "zod";
+
+// Basic extraction
+const field = z.string().meta({ label: "Name" });
+extractMeta(field, "label"); // 'Name'
+
+// Unwraps through optional/nullable/default
+extractMeta(z.string().meta({ label: "Name" }).optional(), "label"); // 'Name'
+extractMeta(z.string().meta({ label: "Name" }).nullable(), "label"); // 'Name'
+extractMeta(z.string().meta({ label: "Name" }).default("hi"), "label"); // 'Name'
+
+// Nested objects: recurses when parent lacks the key
+const address = z.object({
+  city: z.string().meta({ label: "City" }),
+  zip: z.string().meta({ label: "Zip" }),
+});
+extractMeta(address, "label"); // { city: 'City', zip: 'Zip' }
+
+// Object's own meta stops recursion
+const labeled = address.meta({ label: "Address" });
+extractMeta(labeled, "label"); // 'Address'
+
+// Arrays: wraps element meta in an array
+extractMeta(z.array(z.string().meta({ label: "Tag" })), "label"); // ['Tag']
+
+// No meta returns undefined
+extractMeta(z.string(), "label"); // undefined
+```
+
+---
+
+### `getSchemaMeta(params, metaKey)`
+
+Extract the value of a specific meta key from all fields in a Zod schema. Supports discriminated unions via the `discriminator` parameter.
+
+```typescript
+import { getSchemaMeta } from "@zod-utils/core";
+import { z } from "zod";
+
+const schema = z.object({
+  name: z.string().meta({ label: "Name" }),
+  age: z.number().meta({ label: "Age" }),
+  bio: z.string(), // no meta
+});
+
+getSchemaMeta({ schema }, "label");
+// { name: 'Name', age: 'Age' }
+
+// With discriminated union
+const formSchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("create"),
+    name: z.string().meta({ label: "Name" }),
+  }),
+  z.object({
+    mode: z.literal("edit"),
+    id: z.number().meta({ label: "ID" }),
+  }),
+]);
+
+getSchemaMeta(
+  { schema: formSchema, discriminator: { key: "mode", value: "create" } },
+  "label"
+);
+// { name: 'Name' }
+
+// With transforms
+const transformed = z
+  .object({ name: z.string().meta({ label: "Name" }) })
+  .transform((data) => ({ ...data, computed: true }));
+
+getSchemaMeta({ schema: transformed }, "label");
+// { name: 'Name' }
+```
+
+---
+
+### `getMergedSchemaDefaults(params, metaKey)`
+
+Combines schema defaults and meta values into a single result. Meta values take precedence over defaults where both exist. Performs a deep merge for nested objects.
+
+```typescript
+import { getMergedSchemaDefaults } from "@zod-utils/core";
+import { z } from "zod";
+
+const schema = z.object({
+  name: z.string().meta({ label: "Name" }).default("hello"),
+  age: z.number().meta({ label: "Age" }),
+  bio: z.string().default(""),
+});
+
+getMergedSchemaDefaults({ schema }, "label");
+// { name: 'Name', age: 'Age', bio: '' }
+// 'name': meta 'Name' wins over default 'hello'
+// 'age': only meta exists
+// 'bio': only default exists
+
+// Deep merge preserves nested fields from both sources
+const nested = z.object({
+  address: z.object({
+    city: z.string().meta({ label: "City" }).default("NYC"),
+    zip: z.string().default("00000"),
+    state: z.string().meta({ label: "State" }),
+  }),
+});
+
+getMergedSchemaDefaults({ schema: nested }, "label");
+// { address: { city: 'City', zip: '00000', state: 'State' } }
+
+// Works with discriminated unions
+const formSchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("create"),
+    name: z.string().meta({ label: "Name" }).default("New User"),
+    count: z.number().default(0),
+  }),
+  z.object({
+    mode: z.literal("edit"),
+    id: z.number().meta({ label: "ID" }),
+  }),
+]);
+
+getMergedSchemaDefaults(
+  { schema: formSchema, discriminator: { key: "mode", value: "create" } },
+  "label"
+);
+// { name: 'Name', count: 0 }
+```
+
+---
+
 ### `toFieldSelector(props)`
 
 Extracts a `FieldSelector` from props containing schema, name, and optional discriminator. Encapsulates type assertion so callers don't need eslint-disable.

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { z as z$1, util } from 'zod';
-import { SomeType, $InferUnionInput, $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckBigIntFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckLowerCaseDef, $ZodCheckUpperCaseDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckPropertyDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
+import { SomeType, $InferUnionInput, $ZodType, $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
 
 /**
  * Simplifies complex TypeScript types for better IDE hover tooltips and error messages.
@@ -365,6 +365,11 @@ type NameAndDiscriminatorProps<TSchema extends z$1.ZodType, TDiscriminatorKey ex
  */
 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>;
 
+/**
+ * Type-safe helper to iterate over ZodObject shape entries.
+ * @internal
+ */
+declare function getShapeEntries(schema: z.ZodObject): Array<[string, z.ZodType | undefined]>;
 /**
  * Extracts the default value from a Zod field, recursively unwrapping optional, nullable, and union layers.
  *
@@ -650,19 +655,45 @@ 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, discriminator, }: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>) => ReturnType | undefined;
+declare const extractDiscriminatedSchema: <TSchema extends z$1.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TUnwrapped extends z$1.ZodType = UnwrapZodType<TSchema> extends z$1.ZodType ? UnwrapZodType<TSchema> : TSchema, ReturnType extends TUnwrapped extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>, Extract<TDiscriminatorValue, DiscriminatorValue<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>>>> : undefined = TUnwrapped extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>, Extract<TDiscriminatorValue, DiscriminatorValue<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>>>> : undefined>({ schema, discriminator, }: SchemaAndDiscriminatorProps<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 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 extends z$1.ZodPipe<infer In, z$1.ZodType> ? Unwrap<In> : 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>>;
+/**
+ * Extract field from a discriminated union variant.
+ * First extracts the variant using ExtractZodUnionMember, then navigates through it.
+ * @internal
+ */
+type ExtractFromDiscriminatedUnion<TSchema extends z$1.ZodType, TName extends string, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>, TUnwrapped extends z$1.ZodType = UnwrapZodType<TSchema> extends z$1.ZodType ? UnwrapZodType<TSchema> : TSchema, TVariant = TUnwrapped extends z$1.ZodDiscriminatedUnion ? ExtractZodUnionMember<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>, Extract<TDiscriminatorValue, DiscriminatorValue<TUnwrapped, Extract<TDiscriminatorKey, DiscriminatorKey<TUnwrapped>>>>> : never> = TVariant extends z$1.ZodType ? ExtractZodByPath<TVariant, TName> : never;
+/**
+ * Helper type to determine if field extraction should succeed.
+ * Returns true when:
+ * 1. For discriminated unions: discriminator is provided (trust the user)
+ * 2. For non-unions: the path resolves to a valid type (not never)
+ * @internal
+ */
+type CanExtractField<TSchema extends z$1.ZodType, TName extends string, TDiscriminatorKey extends DiscriminatorKey<TSchema>> = IsDiscriminatedUnion<TSchema> extends true ? [TDiscriminatorKey] extends [never] ? false : true : [
+    ExtractZodByPath<TSchema, TName>
+] extends [never] ? false : true;
+/**
+ * Conditional return type for extractFieldFromSchema.
+ * For discriminated unions: extracts variant first, then navigates.
+ * For non-unions: navigates directly.
+ * @internal
+ */
+type ExtractFieldResult<TSchema extends z$1.ZodType, TName extends string, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey> = DiscriminatorValue<TSchema, TDiscriminatorKey>> = CanExtractField<TSchema, TName, TDiscriminatorKey> extends true ? IsDiscriminatedUnion<TSchema> extends true ? [
+    ExtractFromDiscriminatedUnion<TSchema, TName, TDiscriminatorKey, TDiscriminatorValue>
+] extends [never] ? z$1.ZodType : ExtractFromDiscriminatedUnion<TSchema, TName, TDiscriminatorKey, TDiscriminatorValue> & z$1.ZodType : // For non-unions: navigate directly
+ExtractZodByPath<TSchema, TName> & z$1.ZodType : (ExtractZodByPath<TSchema, TName> & 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;
+}): ExtractFieldResult<TSchema, TName, TDiscriminatorKey, TDiscriminatorValue>;
 /**
  * Extends a Zod field with a transformation while preserving its metadata.
  *
@@ -684,6 +715,115 @@ declare function extractFieldFromSchema<TSchema extends z$1.ZodType, TDiscrimina
  */
 declare function extendWithMeta<T extends z$1.ZodType, R extends z$1.ZodType>(field: T, transform: (f: T) => R): R;
 
+/**
+ * Extracts the value of a specific meta key from a Zod field, recursively unwrapping
+ * optional, nullable, default, transform, and union layers.
+ *
+ * For `ZodObject` fields: if the object's own meta contains the target key, returns that
+ * value directly (stops recursion). If not, recurses into shape children and returns
+ * a nested record of meta values.
+ *
+ * @param field - The Zod field to extract meta from
+ * @param metaKey - The meta property key to extract
+ * @returns The meta value if found, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const field = z.string().meta({ label: 'Name' });
+ * extractMeta(field, 'label'); // 'Name'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const field = z.string().meta({ label: 'Name' }).optional();
+ * extractMeta(field, 'label'); // 'Name' (unwraps optional)
+ * ```
+ *
+ * @see {@link getSchemaMeta} for extracting meta from entire schemas
+ * @since 0.3.0
+ */
+declare function extractMeta(field: z.ZodType, metaKey: string): unknown;
+/**
+ * Extracts the value of a specific meta key from all fields in a Zod schema.
+ *
+ * Returns a nested record where each key maps to the meta value for that field.
+ * Fields without the specified meta key are omitted.
+ *
+ * For `ZodObject` fields: if the object has the target meta key in its own meta,
+ * returns that value directly. Otherwise, recurses into shape children.
+ *
+ * Supports discriminated unions via the `discriminator` parameter.
+ *
+ * @param params - Schema and optional discriminator configuration
+ * @param metaKey - The meta property key to extract
+ * @returns Record mapping field names to their meta values
+ *
+ * To get typed meta keys with autocomplete, augment Zod's `GlobalMeta` interface:
+ *
+ * ```typescript
+ * // types/zod.ts
+ * import * as z from 'zod';
+ *
+ * declare module 'zod' {
+ *   interface GlobalMeta {
+ *     label: string;               // static type for all schemas
+ *     type: z.$output;             // resolves to the schema's output type
+ *     inputType: z.$input;         // resolves to the schema's input type
+ *     placeholder?: string;
+ *   }
+ * }
+ * ```
+ *
+ * With `z.$output` / `z.$input`, Zod automatically types `.meta()` values
+ * based on each schema's inferred type:
+ *
+ * ```typescript
+ * z.string().meta({ type: 'hello' })  // ✅ type is string
+ * z.string().meta({ type: 42 })       // ❌ TypeScript error — expects string
+ * z.number().meta({ type: 42 })       // ✅ type is number
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const schema = z.object({
+ *   name: z.string().meta({ label: 'Name' }),
+ *   age: z.number().meta({ label: 'Age' }),
+ * });
+ * getSchemaMeta({ schema }, 'label');
+ * // { name: 'Name', age: 'Age' }
+ * ```
+ *
+ * @see {@link extractMeta} for extracting meta from individual fields
+ * @since 0.3.0
+ */
+declare function getSchemaMeta<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>(params: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>, metaKey: string): Simplify<Partial<z.input<TSchema>>>;
+/**
+ * Combines schema defaults and meta values into a single result.
+ * Meta values take precedence over defaults where both exist.
+ * For nested objects, performs a deep merge so that fields from both
+ * sources are preserved at every level.
+ *
+ * @param params - Schema and optional discriminator configuration
+ * @param metaKey - The meta property key to extract
+ * @returns Deep-merged record of defaults and meta values (meta wins on conflict)
+ *
+ * @example
+ * ```typescript
+ * const schema = z.object({
+ *   name: z.string().meta({ label: 'Name' }).default('hello'),
+ *   age: z.number().meta({ label: 'Age' }),
+ *   bio: z.string().default(''),
+ * });
+ * getMergedSchemaDefaults({ schema }, 'label');
+ * // { name: 'Name', age: 'Age', bio: '' }
+ * ```
+ *
+ * @see {@link getSchemaDefaults} for extracting only defaults
+ * @see {@link getSchemaMeta} for extracting only meta
+ * @since 0.5.0
+ */
+declare function getMergedSchemaDefaults<TSchema extends z.ZodType, TDiscriminatorKey extends DiscriminatorKey<TSchema>, TDiscriminatorValue extends DiscriminatorValue<TSchema, TDiscriminatorKey>>(params: SchemaAndDiscriminatorProps<TSchema, TDiscriminatorKey, TDiscriminatorValue>, metaKey: string): Simplify<Partial<z.input<TSchema>>>;
+
 /**
  * Type representing a Zod type that has an unwrap method
  */
@@ -710,7 +850,7 @@ type Unwrappable = {
  *
  * @since 0.1.0
  */
-declare function canUnwrap(field: z$1.ZodTypeAny): field is z$1.ZodTypeAny & Unwrappable;
+declare function canUnwrap(field: z$1.ZodType | $ZodType): field is (z$1.ZodType | $ZodType) & Unwrappable;
 /**
  * Type guard that checks if a Zod field is a ZodPipe with a ZodType input.
  *
@@ -719,7 +859,7 @@ declare function canUnwrap(field: z$1.ZodTypeAny): field is z$1.ZodTypeAny & Unw
  * @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>;
+declare function isPipeWithZodInput(field: z$1.ZodType | $ZodType): 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.
  *
@@ -816,7 +956,7 @@ declare function tryStripNullishOnly(field: z$1.ZodTypeAny): z$1.ZodType | false
  * @see {@link tryStripNullishOnly} for union nullish stripping logic
  * @since 0.1.0
  */
-declare const getPrimitiveType: <T extends z$1.ZodType>(field: T) => z$1.ZodTypeAny;
+declare const getPrimitiveType: <T extends z$1.ZodType>(field: T) => z$1.ZodType;
 type StripZodDefault<T> = T extends z$1.ZodDefault<infer Inner> ? StripZodDefault<Inner> : T extends z$1.ZodOptional<infer Inner> ? z$1.ZodOptional<StripZodDefault<Inner>> : T extends z$1.ZodNullable<infer Inner> ? z$1.ZodNullable<StripZodDefault<Inner>> : T;
 /**
  * Removes default values from a Zod field while preserving other wrapper types.
@@ -948,7 +1088,7 @@ declare const requiresValidInput: <T extends z$1.ZodType>(field: T) => boolean;
  *
  * @since 0.4.0
  */
-type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckMultipleOfDef | $ZodCheckNumberFormatDef | $ZodCheckBigIntFormatDef | $ZodCheckMaxSizeDef | $ZodCheckMinSizeDef | $ZodCheckSizeEqualsDef | $ZodCheckMaxLengthDef | $ZodCheckMinLengthDef | $ZodCheckLengthEqualsDef | $ZodCheckStringFormatDef | $ZodCheckRegexDef | $ZodCheckLowerCaseDef | $ZodCheckUpperCaseDef | $ZodCheckIncludesDef | $ZodCheckStartsWithDef | $ZodCheckEndsWithDef | $ZodCheckPropertyDef | $ZodCheckMimeTypeDef | $ZodCheckOverwriteDef;
+type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckMultipleOfDef | $ZodCheckNumberFormatDef | $ZodCheckMaxSizeDef | $ZodCheckMinSizeDef | $ZodCheckSizeEqualsDef | $ZodCheckMaxLengthDef | $ZodCheckMinLengthDef | $ZodCheckLengthEqualsDef | $ZodCheckStringFormatDef | $ZodCheckRegexDef | $ZodCheckIncludesDef | $ZodCheckStartsWithDef | $ZodCheckEndsWithDef | $ZodCheckMimeTypeDef | $ZodCheckOverwriteDef;
 /**
  * Extracts all validation check definitions from a Zod schema field.
  *
@@ -1024,6 +1164,7 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
  * @see {@link ZodUnionCheck} for all supported check types
  * @since 0.4.0
  */
-declare function getFieldChecks<T extends z$1.ZodTypeAny>(field: T): Array<ZodUnionCheck>;
+declare function getFieldChecks<T extends z$1.ZodType | $ZodType>(field: T): Array<ZodUnionCheck>;
+declare function extractCheck(check: z$1.core.$ZodCheck<never>): ZodUnionCheck[];
 
-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 };
+export { type CommonFields, type DiscriminatedInput, type DiscriminatorKey, type DiscriminatorProps, type DiscriminatorValue, type ExtractZodByPath, type ExtractZodUnionMember, 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, extractCheck, extractDefaultValue, extractDiscriminatedSchema, extractFieldFromSchema, extractMeta, getFieldChecks, getMergedSchemaDefaults, getPrimitiveType, getSchemaDefaults, getSchemaMeta, getShapeEntries, isPipeWithZodInput, removeDefault, requiresValidInput, tryStripNullishOnly };