uni-types 1.1.0 → 1.2.0

package/dist/index.d.mts

@@ -428,367 +428,1132 @@ type DeepReadonly<T> = T extends BuiltIn ? T : T extends Map<infer K, infer V> ?
  */
 type DeepMutable<T> = T extends BuiltIn ? T : T extends Map<infer K, infer V> ? Map<DeepMutable<K>, DeepMutable<V>> : T extends Set<infer V> ? Set<DeepMutable<V>> : T extends readonly (infer E)[] ? DeepMutable<E>[] : T extends object ? { -readonly [P in keyof T]: DeepMutable<T[P]> } : T;
 //#endregion
-//#region src/functions/index.d.ts
+//#region src/ecosystem/prisma.d.ts
 /**
- * Function type utilities
+ * Prisma ORM integration types
+ *
+ * These types help work with Prisma models and operations.
+ * Note: Prisma is an optional peer dependency.
  */
 /**
- * Get function parameters as tuple
+ * Prisma model type helper
  *
  * @example
  * ```ts
- * type Fn = (a: string, b: number) => boolean
- * Parameters<Fn>    // [string, number]
+ * // Assuming you have a User model in Prisma
+ * type UserModel = PrismaModel<User>
  * ```
  */
-type Parameters<T> = T extends ((...args: infer P) => any) ? P : never;
+type PrismaModel<T> = T;
 /**
- * Get function return type
+ * Prisma create input type
  *
  * @example
  * ```ts
- * type Fn = (a: string) => number
- * ReturnType<Fn>    // number
+ * type CreateInput = PrismaCreateInput<User>
+ * // { name: string; email: string; age?: number }
  * ```
  */
-type ReturnType<T> = T extends ((...args: any[]) => infer R) ? R : any;
+type PrismaCreateInput<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K] } & { [K in keyof T as undefined extends T[K] ? K : never]?: T[K] };
 /**
- * Get Nth parameter type (0-indexed)
+ * Prisma update input type
  *
  * @example
  * ```ts
- * type Fn = (a: string, b: number, c: boolean) => void
- * NthParameter<Fn, 0>  // string
- * NthParameter<Fn, 1>  // number
- * NthParameter<Fn, 2>  // boolean
+ * type UpdateInput = PrismaUpdateInput<User>
+ * // { name?: string; email?: string; age?: number }
  * ```
  */
-type NthParameter<T, N extends number> = T extends ((...args: infer P) => any) ? P[N] : never;
+type PrismaUpdateInput<T> = { [K in keyof T]?: T[K] | null };
 /**
- * Extract async function return type (unwraps Promise)
+ * Prisma where input type for unique lookup
  *
  * @example
  * ```ts
- * type AsyncFn = () => Promise<string>
- * AsyncReturnType<AsyncFn>  // string
+ * type UniqueWhere = PrismaUniqueWhere<User, 'id' | 'email'>
+ * // { id: string } | { email: string }
  * ```
  */
-type AsyncReturnType<T> = T extends ((...args: any[]) => Promise<infer R>) ? R : T extends ((...args: any[]) => infer R) ? R : never;
+type PrismaUniqueWhere<T, UniqueFields extends keyof T> = { [K in UniqueFields]: { [P in K]: T[P] } }[UniqueFields];
 /**
- * Get function this parameter type
+ * Prisma where input type
  *
  * @example
  * ```ts
- * type Fn = (this: { x: number }) => void
- * ThisParameterType<Fn>  // { x: number }
+ * type WhereInput = PrismaWhereInput<User>
+ * // { id?: string; name?: string; AND?: WhereInput[]; OR?: WhereInput[] }
  * ```
  */
-type ThisParameterType<T> = T extends ((this: infer U, ...args: any[]) => any) ? U : unknown;
+type PrismaWhereInput<T> = Partial<T> & {
+  AND?: PrismaWhereInput<T>[];
+  OR?: PrismaWhereInput<T>[];
+  NOT?: PrismaWhereInput<T>[];
+};
 /**
- * Omit this parameter from function type
+ * Prisma order by input type
  *
  * @example
  * ```ts
- * type Fn = (this: { x: number }, a: string) => void
- * OmitThisParameter<Fn>  // (a: string) => void
+ * type OrderBy = PrismaOrderByInput<User>
+ * // { name?: 'asc' | 'desc'; createdAt?: 'asc' | 'desc' }
  * ```
  */
-type OmitThisParameter<T> = T extends ((this: any, ...args: infer A) => infer R) ? (...args: A) => R : T;
+type PrismaOrderByInput<T> = { [K in keyof T]?: 'asc' | 'desc' };
 /**
- * Check if type is a function
+ * Prisma select type
  *
  * @example
  * ```ts
- * IsFunction<() => void>  // true
- * IsFunction<string>      // false
+ * type Select = PrismaSelect<User, 'name' | 'email'>
+ * // { name: true; email: true }
  * ```
  */
-type IsFunction<T> = T extends ((...args: any[]) => any) ? true : false;
+type PrismaSelect<T, Keys extends keyof T = keyof T> = { [K in Keys]?: true };
 /**
- * Check if type is an async function
+ * Prisma include type (for relations)
  *
  * @example
  * ```ts
- * IsAsyncFunction<() => Promise<string>>  // true
- * IsAsyncFunction<() => string>           // false
+ * type Include = PrismaInclude<User, 'posts'>
+ * // { posts: true }
  * ```
  */
-type IsAsyncFunction<T> = T extends ((...args: any[]) => Promise<any>) ? true : false;
+type PrismaInclude<T, Keys extends keyof T = keyof T> = { [K in Keys]?: true | {
+  select?: Partial<T>;
+} };
 /**
- * Make function parameters optional
+ * Extract scalar (non-relation) fields from a Prisma model
  *
  * @example
  * ```ts
- * type Fn = (a: string, b: number) => void
- * OptionalParameters<Fn>  // (a?: string, b?: number) => void
+ * type Scalars = PrismaScalarFields<User>
+ * // 'id' | 'name' | 'email' | 'createdAt'
  * ```
  */
-type OptionalParameters<T> = T extends ((...args: any[]) => infer R) ? (...args: Partial<Parameters<T>>) => R : never;
+type PrismaScalarFields<T> = { [K in keyof T]: T[K] extends Date | string | number | boolean | bigint | Buffer ? K : T[K] extends Date | string | number | boolean | bigint | Buffer | null ? K : never }[keyof T];
 /**
- * Append a parameter to a function
+ * Extract relation fields from a Prisma model
  *
  * @example
  * ```ts
- * type Fn = (a: string) => void
- * AppendParameter<Fn, number>  // (a: string, b: number) => void
+ * type Relations = PrismaRelationFields<User>
+ * // 'posts' | 'comments'
  * ```
  */
-type AppendParameter<T, P> = T extends ((...args: infer A) => infer R) ? (...args: [...A, P]) => R : never;
+type PrismaRelationFields<T> = Exclude<keyof T, PrismaScalarFields<T>>;
 /**
- * Prepend a parameter to a function
- *
- * @example
- * ```ts
- * type Fn = (a: string) => void
- * PrependParameter<Fn, number>  // (a: number, b: string) => void
- * ```
+ * Prisma pagination args
  */
-type PrependParameter<T, P> = T extends ((...args: infer A) => infer R) ? (...args: [P, ...A]) => R : never;
+interface PrismaPagination {
+  skip?: number;
+  take?: number;
+  cursor?: Record<string, unknown>;
+}
+/**
+ * Prisma find many args
+ */
+interface PrismaFindManyArgs<T> {
+  where?: PrismaWhereInput<T>;
+  orderBy?: PrismaOrderByInput<T> | PrismaOrderByInput<T>[];
+  skip?: number;
+  take?: number;
+  cursor?: PrismaUniqueWhere<T, keyof T>;
+  select?: Partial<Record<keyof T, true>>;
+  include?: Partial<Record<keyof T, true | object>>;
+}
+/**
+ * Prisma find first args
+ */
+interface PrismaFindFirstArgs<T> {
+  where?: PrismaWhereInput<T>;
+  orderBy?: PrismaOrderByInput<T> | PrismaOrderByInput<T>[];
+  cursor?: PrismaUniqueWhere<T, keyof T>;
+  select?: Partial<Record<keyof T, true>>;
+  include?: Partial<Record<keyof T, true | object>>;
+}
+/**
+ * Prisma find unique args
+ */
+interface PrismaFindUniqueArgs<T, UniqueFields extends keyof T> {
+  where: PrismaUniqueWhere<T, UniqueFields>;
+  select?: Partial<Record<keyof T, true>>;
+  include?: Partial<Record<keyof T, true | object>>;
+}
+/**
+ * Prisma create args
+ */
+interface PrismaCreateArgs<T> {
+  data: PrismaCreateInput<T>;
+  select?: Partial<Record<keyof T, true>>;
+  include?: Partial<Record<keyof T, true | object>>;
+}
+/**
+ * Prisma update args
+ */
+interface PrismaUpdateArgs<T, UniqueFields extends keyof T> {
+  where: PrismaUniqueWhere<T, UniqueFields>;
+  data: PrismaUpdateInput<T>;
+  select?: Partial<Record<keyof T, true>>;
+  include?: Partial<Record<keyof T, true | object>>;
+}
+/**
+ * Prisma delete args
+ */
+interface PrismaDeleteArgs<T, UniqueFields extends keyof T> {
+  where: PrismaUniqueWhere<T, UniqueFields>;
+  select?: Partial<Record<keyof T, true>>;
+  include?: Partial<Record<keyof T, true | object>>;
+}
+/**
+ * Prisma upsert args
+ */
+interface PrismaUpsertArgs<T, UniqueFields extends keyof T> {
+  where: PrismaUniqueWhere<T, UniqueFields>;
+  create: PrismaCreateInput<T>;
+  update: PrismaUpdateInput<T>;
+  select?: Partial<Record<keyof T, true>>;
+  include?: Partial<Record<keyof T, true | object>>;
+}
+/**
+ * Prisma count args
+ */
+interface PrismaCountArgs<T> {
+  where?: PrismaWhereInput<T>;
+  select?: Partial<Record<keyof T, true>>;
+}
+/**
+ * Prisma aggregate args
+ */
+interface PrismaAggregateArgs<T> {
+  where?: PrismaWhereInput<T>;
+  orderBy?: PrismaOrderByInput<T> | PrismaOrderByInput<T>[];
+  skip?: number;
+  take?: number;
+  _count?: true | {
+    _all?: true;
+  } | Partial<Record<keyof T, true>>;
+  _avg?: Partial<Record<keyof T, true>>;
+  _sum?: Partial<Record<keyof T, true>>;
+  _min?: Partial<Record<keyof T, true>>;
+  _max?: Partial<Record<keyof T, true>>;
+}
+/**
+ * Prisma group by args
+ */
+interface PrismaGroupByArgs<T> {
+  where?: PrismaWhereInput<T>;
+  orderBy?: PrismaOrderByInput<T> | PrismaOrderByInput<T>[];
+  by: (keyof T)[];
+  having?: PrismaWhereInput<T>;
+  take?: number;
+  skip?: number;
+  _count?: true | {
+    _all?: true;
+  } | Partial<Record<keyof T, true>>;
+  _avg?: Partial<Record<keyof T, true>>;
+  _sum?: Partial<Record<keyof T, true>>;
+  _min?: Partial<Record<keyof T, true>>;
+  _max?: Partial<Record<keyof T, true>>;
+}
 //#endregion
-//#region src/guards/index.d.ts
+//#region src/ecosystem/react.d.ts
 /**
- * Check if type is an array
+ * React component props utilities
  *
- * @example
- * ```ts
- * IsArray<string[]> // true
- * IsArray<string>   // false
- * ```
+ * These types help work with React component props.
+ * Note: React is an optional peer dependency.
  */
-type IsArray<T> = T extends readonly unknown[] ? T extends readonly [...unknown[]] ? true : false : false;
 /**
- * Check if type is a tuple
+ * Extract props from a React component
  *
  * @example
- * ```ts
- * IsTuple<[string, number]> // true
- * IsTuple<string[]>         // false
+ * ```tsx
+ * import type { ComponentProps } from 'uni-types'
+ *
+ * type ButtonProps = ComponentProps<'button'>
+ * type InputProps = ComponentProps<'input'>
  * ```
  */
-type IsTuple<T> = T extends readonly [unknown, ...unknown[]] ? T extends readonly unknown[] ? number extends T['length'] ? false : true : false : false;
+type ComponentProps<T> = T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : T extends ReactComponentType<infer P> ? P : never;
 /**
- * Check if two types are equal
+ * Get props with ref included
  *
  * @example
- * ```ts
- * IsEqual<string, string>   // true
- * IsEqual<string, number>   // false
+ * ```tsx
+ * type ButtonPropsWithRef = ComponentPropsWithRef<'button'>
  * ```
  */
-type IsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
-/**
- * Check if type is any
- */
-type IsAny<T> = 0 extends 1 & T ? true : false;
+type ComponentPropsWithRef<T> = T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] & {
+  ref?: unknown;
+} : T extends ReactComponentType<infer P> ? P & {
+  ref?: unknown;
+} : never;
 /**
- * Check if type is never
+ * Add children to props
+ *
+ * @example
+ * ```tsx
+ * type Props = PropsWithChildren<{ name: string }>
+ * // { name: string; children?: React.ReactNode }
+ * ```
  */
-type IsNever<T> = [T] extends [never] ? true : false;
+type PropsWithChildren<P = unknown> = P & {
+  children?: ReactNode;
+};
 /**
- * Check if type is unknown
+ * Remove children from props
+ *
+ * @example
+ * ```tsx
+ * type Props = PropsWithoutChildren<{ name: string; children: ReactNode }>
+ * // { name: string }
+ * ```
  */
-type IsUnknown<T> = IsEqual<T, unknown> extends true ? IsAny<T> extends true ? false : true : false;
-//#endregion
-//#region src/infer/index.d.ts
+type PropsWithoutChildren<P> = Omit<P, 'children'>;
 /**
- * Get Promise value type (recursive unwrapping)
+ * Extract the prop types from a component
  *
  * @example
- * ```ts
- * Awaited<Promise<string>>        // string
- * Awaited<Promise<Promise<number>>> // number
+ * ```tsx
+ * const MyComponent = (props: { name: string; age: number }) => null
+ * type Props = ExtractPropTypes<typeof MyComponent>
+ * // { name: string; age: number }
  * ```
  */
-type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
+type ExtractPropTypes<T> = T extends ReactComponentType<infer P> ? P : never;
 /**
- * Get array element type
+ * Get required props from a component
  *
  * @example
- * ```ts
- * ArrayElement<string[]>  // string
- * ArrayElement<(number | boolean)[]> // number | boolean
+ * ```tsx
+ * interface Props {
+ *   name: string      // required
+ *   age?: number      // optional
+ *   onChange?: () => void
+ * }
+ *
+ * type Required = RequiredProps<Props>
+ * // 'name'
  * ```
  */
-type ArrayElement<T> = T extends readonly (infer E)[] ? E : never;
+type RequiredProps<P> = { [K in keyof P]-?: {} extends Pick<P, K> ? never : K }[keyof P];
 /**
- * Get object value type
+ * Get optional props from a component
  *
  * @example
- * ```ts
- * ValueOf<{ a: string; b: number }> // string | number
+ * ```tsx
+ * interface Props {
+ *   name: string      // required
+ *   age?: number      // optional
+ *   onChange?: () => void
+ * }
+ *
+ * type Optional = OptionalProps<Props>
+ * // 'age' | 'onChange'
  * ```
  */
-type ValueOf<T> = T[keyof T];
+type OptionalProps<P> = { [K in keyof P]-?: {} extends Pick<P, K> ? K : never }[keyof P];
 /**
- * Get function type keys
+ * Props for forward ref components
  *
  * @example
- * ```ts
- * interface Obj {
- *   name: string
- *   onClick: () => void
- *   onChange: (v: string) => void
- * }
- * FunctionKeys<Obj> // 'onClick' | 'onChange'
+ * ```tsx
+ * type InputProps = ForwardRefProps<'input'>
  * ```
  */
-type FunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
+type ForwardRefProps<T extends keyof JSX.IntrinsicElements> = ComponentProps<T> & {
+  ref?: unknown;
+};
 /**
- * Get non-function type keys
+ * Merge props with default props
  *
  * @example
- * ```ts
- * interface Obj {
- *   name: string
- *   onClick: () => void
+ * ```tsx
+ * interface Props {
+ *   size?: 'sm' | 'md' | 'lg'
+ *   variant?: 'primary' | 'secondary'
  * }
- * NonFunctionKeys<Obj> // 'name'
+ *
+ * type WithDefaults = MergeDefaultProps<Props, { size: 'md' }>
+ * // size becomes optional with default 'md'
  * ```
  */
-type NonFunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? never : K }[keyof T];
+type MergeDefaultProps<P, D extends Partial<P>> = Omit<P, keyof D> & { [K in keyof D]?: P extends Record<K, infer V> ? V : D[K] };
 /**
- * Get function's first parameter type
+ * Props with style
  */
-type FirstParameter<T> = T extends ((first: infer F, ...rest: any[]) => any) ? F : never;
+type PropsWithStyle<P = unknown> = P & {
+  style?: CSSProperties;
+};
 /**
- * Extract function properties
+ * Props with className
  */
-type FunctionOnly<T> = Pick<T, FunctionKeys<T>>;
+type PropsWithClassName<P = unknown> = P & {
+  className?: string;
+};
 /**
- * Extract non-function properties
+ * Props with style and className
  */
-type DataOnly<T> = Pick<T, NonFunctionKeys<T>>;
+type PropsWithStyleAndClassName<P = unknown> = P & {
+  style?: CSSProperties;
+  className?: string;
+};
+/**
+ * Event handler type
+ */
+type EventHandler<E = SyntheticEvent> = (event: E) => void;
+/**
+ * Change event handler
+ */
+type ChangeEventHandler = (event: SyntheticEvent) => void;
+/**
+ * Mouse event handler
+ */
+type MouseEventHandler = (event: SyntheticEvent) => void;
+/**
+ * Keyboard event handler
+ */
+type KeyboardEventHandler = (event: SyntheticEvent) => void;
+/**
+ * Focus event handler
+ */
+type FocusEventHandler = (event: SyntheticEvent) => void;
+/**
+ * Form event handler
+ */
+type FormEventHandler = (event: SyntheticEvent) => void;
+type ReactComponentType<P = unknown> = (props: P) => unknown;
+type ReactNode = unknown;
+interface SyntheticEvent {
+  type: string;
+  nativeEvent: unknown;
+  currentTarget: unknown;
+  target: unknown;
+}
+type CSSProperties = Record<string, string | number | undefined>;
+declare namespace JSX {
+  type IntrinsicElements = Record<string, unknown>;
+}
 //#endregion
-//#region src/utils/index.d.ts
+//#region src/ecosystem/trpc.d.ts
 /**
- * Merge two types (latter overrides former)
+ * tRPC integration types
+ *
+ * These types help work with tRPC routers and procedures.
+ * Note: tRPC is an optional peer dependency.
+ */
+/**
+ * tRPC router shape
  *
  * @example
  * ```ts
- * Merge<{ a: string; b: number }, { b: boolean; c: string }>
- * // { a: string; b: boolean; c: string }
+ * import { initTRPC } from '@trpc/server'
+ *
+ * const t = initTRPC.create()
+ *
+ * const router = t.router({
+ *   user: t.procedure.query(() => ({ name: 'John' })),
+ *   post: t.procedure.query(() => ({ title: 'Hello' }))
+ * })
+ *
+ * type RouterShape = TRPCRouterShape<typeof router>
  * ```
  */
-type Merge<T, U> = Omit<T, keyof U> & U;
+type TRPCRouterShape<T> = T extends {
+  _def: {
+    router: infer R;
+  };
+} ? R : T;
 /**
- * Non null/undefined
+ * Extract input type from tRPC procedure
  *
  * @example
  * ```ts
- * NonNullable<string | null | undefined> // string
+ * const procedure = t.procedure.input(z.object({ name: z.string() }))
+ *
+ * type Input = TRPCProcedureInput<typeof procedure>
+ * // { name: string }
  * ```
  */
-type NonNullable$1<T> = T & {};
+type TRPCProcedureInput<T> = T extends {
+  _def: {
+    inputs: infer I;
+  };
+} ? I extends [infer First, ...unknown[]] ? First : I : T extends {
+  _def: {
+    input: infer I;
+  };
+} ? I : never;
 /**
- * Exclusive properties (only one can be selected)
+ * Extract output type from tRPC procedure
  *
  * @example
  * ```ts
- * type Result = Exclusive<{ type: 'a'; valueA: string } | { type: 'b'; valueB: number }, 'type'>
- * // Only type: 'a' or type: 'b' can be selected
+ * const procedure = t.procedure.output(z.object({ name: z.string() }))
+ *
+ * type Output = TRPCProcedureOutput<typeof procedure>
+ * // { name: string }
  * ```
  */
-type Exclusive<T, K extends keyof T> = T extends unknown ? Omit<T, K> & { [P in K]?: never } : never;
+type TRPCProcedureOutput<T> = T extends {
+  _def: {
+    output: infer O;
+  };
+} ? O : never;
 /**
- * Remove null and undefined from all properties
+ * tRPC procedure type
  */
-type NoNullish<T> = { [K in keyof T]: NonNullable$1<T[K]> };
+type TRPCProcedureType = 'query' | 'mutation' | 'subscription';
 /**
- * Make all properties optional while preserving undefined/null values
+ * Extract procedure type from tRPC procedure
  */
-type LoosePartial<T> = { [P in keyof T]?: T[P] };
+type TRPCExtractProcedureType<T> = T extends {
+  _def: {
+    type: infer P;
+  };
+} ? P extends TRPCProcedureType ? P : never : never;
 /**
- * Literal types
+ * tRPC error shape
+ *
+ * @example
+ * ```ts
+ * type Error = TRPCErrorShape<{ message: string }>
+ * ```
  */
-type Literal = string | number | boolean | undefined | null | void | bigint;
+interface TRPCErrorShape<T = unknown> {
+  message: string;
+  code: string;
+  data?: T;
+}
 /**
- * Exact literal types
+ * tRPC context type
+ *
+ * @example
+ * ```ts
+ * interface Context {
+ *   user?: { id: string }
+ *   session: Session
+ * }
+ *
+ * type AppContext = TRPCContext<Context>
+ * ```
  */
-type LiteralString<T extends string> = T;
-type LiteralNumber<T extends number> = T;
-type LiteralBoolean<T extends boolean> = T;
+type TRPCContext<T> = T;
 /**
- * Nullable type
+ * tRPC middleware type
+ *
+ * @example
+ * ```ts
+ * type Middleware = TRPCMiddleware<{ user: User }>
+ * ```
  */
-type Nullable<T> = T | null;
+type TRPCMiddleware<T = unknown> = (opts: {
+  ctx: T;
+  next: () => Promise<void>;
+}) => Promise<void>;
 /**
- * Optional type
+ * tRPC router record
  */
-type Optional<T> = T | undefined;
+type TRPCRouterRecord = Record<string, unknown>;
 /**
- * Maybe type (nullable and optional)
+ * Merge multiple tRPC routers
  */
-type Maybe<T> = T | null | undefined;
+type TRPCMergeRouters<T extends TRPCRouterRecord[]> = T extends [infer First extends TRPCRouterRecord, ...infer Rest extends TRPCRouterRecord[]] ? Rest extends [] ? First : First & TRPCMergeRouters<Rest> : Record<string, never>;
 /**
- * Convert string to camelCase
+ * tRPC procedure builder
  */
-type CamelCase<S extends string> = S extends `${infer P}_${infer Q}` ? `${P}${Capitalize<CamelCase<Q>>}` : S extends `${infer P}-${infer Q}` ? `${P}${Capitalize<CamelCase<Q>>}` : S;
+interface TRPCProcedureBuilder<T = unknown> {
+  _def: {
+    input: T;
+    output: unknown;
+    type: TRPCProcedureType;
+  };
+}
 /**
- * Convert object keys to camelCase
+ * Get all query procedures from router
  */
-type CamelCaseKeys<T> = { [K in keyof T as CamelCase<string & K>]: T[K] };
+type TRPCQueries<T> = T extends object ? { [K in keyof T]: T[K] extends {
+  _def: {
+    type: 'query';
+  };
+} ? K : never }[keyof T] : never;
 /**
- * Convert string to snake_case
- * Handles consecutive uppercase letters correctly (e.g., XMLParser -> xml_parser)
+ * Get all mutation procedures from router
  */
-type SnakeCase<S extends string> = S extends `${infer C0}${infer C1}${infer Rest}` ? C0 extends Uppercase<C0> ? C0 extends Lowercase<C0> ? `${C0}${SnakeCase<`${C1}${Rest}`>}` : C1 extends Uppercase<C1> ? C1 extends Lowercase<C1> ? `_${Lowercase<C0>}${SnakeCase<`${C1}${Rest}`>}` : `${Lowercase<C0>}${SnakeCase<`${C1}${Rest}`>}` : `_${Lowercase<C0>}${SnakeCase<`${C1}${Rest}`>}` : `${C0}${SnakeCase<`${C1}${Rest}`>}` : S extends `${infer C}` ? C extends Uppercase<C> ? C extends Lowercase<C> ? `${C}` : `_${Lowercase<C>}` : `${C}` : S;
+type TRPCMutations<T> = T extends object ? { [K in keyof T]: T[K] extends {
+  _def: {
+    type: 'mutation';
+  };
+} ? K : never }[keyof T] : never;
 /**
- * Convert object keys to snake_case
+ * Get all subscription procedures from router
  */
-type SnakeCaseKeys<T> = { [K in keyof T as SnakeCase<string & K>]: T[K] };
+type TRPCSubscriptions<T> = T extends object ? { [K in keyof T]: T[K] extends {
+  _def: {
+    type: 'subscription';
+  };
+} ? K : never }[keyof T] : never;
 /**
- * Require at least one property
+ * tRPC client type
  */
-type AtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & { [K in Keys]: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>> }[Keys];
+interface TRPCClient<T> {
+  query: <K extends keyof T>(procedure: K, input?: unknown) => Promise<TRPCProcedureOutput<T[K]>>;
+  mutate: <K extends keyof T>(procedure: K, input?: unknown) => Promise<TRPCProcedureOutput<T[K]>>;
+  subscribe: <K extends keyof T>(procedure: K, input?: unknown) => Promise<void>;
+}
 /**
- * Strict extract
+ * tRPC caller type
  */
-type StrictExtract<T, U extends keyof any> = T extends Record<U, any> ? T : never;
+type TRPSCaller<T, Context = unknown> = (ctx: Context) => TRPCCallerRouter<T>;
 /**
- * Strict exclude
+ * tRPC caller router type
  */
-type StrictExclude<T, U extends T> = T extends U ? never : T;
+type TRPCCallerRouter<T> = { [K in keyof T]: TRPCProcedureCaller<T[K]> };
 /**
- * Convert union type to intersection type
+ * tRPC procedure caller type
  */
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type TRPCProcedureCaller<T> = (input: TRPCProcedureInput<T>) => Promise<TRPCProcedureOutput<T>>;
+//#endregion
+//#region src/ecosystem/vue.d.ts
 /**
- * Convert union type to tuple
+ * Vue component props utilities
+ *
+ * These types help work with Vue component props.
+ * Note: Vue is an optional peer dependency.
  */
-type UnionToTuple<T> = UnionToIntersection<T extends unknown ? (t: T) => T : never> extends ((_: any) => infer W) ? [...UnionToTuple<Exclude<T, W>>, W] : [];
 /**
- * Get all required keys of a type
+ * Vue prop type definition
  *
  * @example
- * ```ts
- * interface User {
+ * ```vue
+ * <script setup lang="ts">
+ * const props = defineProps<{
  *   name: string
  *   age?: number
- * }
- * RequiredKeys<User> // 'name'
+ * }>()
+ * </script>
  * ```
  */
-type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
+interface VuePropType<T> {
+  type: VuePropConstructor<T>;
+  required?: boolean;
+  default?: T | (() => T);
+}
 /**
- * Get all optional keys of a type
+ * Vue prop constructor types
+ */
+type VuePropConstructor<T> = (abstract new (...args: any[]) => T & object) | {
+  (): T;
+} | {
+  new (...args: any[]): T & object;
+};
+/**
+ * Extract props from Vue component options
  *
  * @example
  * ```ts
- * interface User {
- *   name: string
- *   age?: number
+ * interface Props {
+ *   title: string
+ *   count?: number
  * }
- * OptionalKeys<User> // 'age'
+ *
+ * type Props = ExtractVueProps<Props>
  * ```
  */
-type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];
+type ExtractVueProps<T> = T extends {
+  props: infer P;
+} ? P : T;
 /**
- * Get all writable (non-readonly) keys of a type
+ * Vue component raw props (before normalization)
+ */
+type VueRawProps = Record<string, VuePropConstructor<unknown> | VuePropType<unknown>>;
+/**
+ * Normalize Vue props to TypeScript types
  *
  * @example
  * ```ts
- * interface User {
- *   name: string
+ * const props = {
+ *   name: String,
+ *   age: { type: Number, required: false }
+ * }
+ *
+ * type Normalized = NormalizeVueProps<typeof props>
+ * // { name: string; age?: number }
+ * ```
+ */
+type NormalizeVueProps<T extends VueRawProps> = { [K in keyof T]: T[K] extends VuePropType<infer V> ? T[K] extends {
+  required: true;
+} ? V : V | undefined : T[K] extends VuePropConstructor<infer V> ? V | undefined : never };
+/**
+ * Vue emit function type
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const emit = defineEmits<{
+ *   change: [value: string]
+ *   submit: []
+ * }>()
+ * </script>
+ * ```
+ */
+type VueEmitType<T extends Record<string, unknown[]>> = { [K in keyof T]: (...args: T[K]) => void };
+/**
+ * Vue model props (for v-model)
+ *
+ * @example
+ * ```ts
+ * interface Props {
+ *   modelValue: string
+ *   'onUpdate:modelValue'?: (value: string) => void
+ * }
+ *
+ * type Model = VueModelProps<'modelValue', string>
+ * ```
+ */
+type VueModelProps<K extends string, T> = { [P in K]: T } & { [P in `onUpdate:${K}`]?: (value: T) => void };
+/**
+ * Vue prop with default value
+ */
+interface VuePropWithDefault<T, D extends T> {
+  type: VuePropConstructor<T>;
+  required: false;
+  default: D;
+}
+/**
+ * Required Vue prop
+ */
+interface RequiredVueProp<T> {
+  type: VuePropConstructor<T>;
+  required: true;
+}
+/**
+ * Optional Vue prop
+ */
+interface OptionalVueProp<T> {
+  type: VuePropConstructor<T>;
+  required: false;
+}
+/**
+ * Vue slot type
+ */
+type VueSlot<T = Record<string, unknown>> = (props: T) => unknown;
+/**
+ * Vue slots type
+ */
+type VueSlots<T extends Record<string, Record<string, unknown> | undefined>> = { [K in keyof T]: VueSlot<NonNullable<T[K]>> };
+/**
+ * Vue expose type
+ */
+type VueExpose<T extends Record<string, (...args: any[]) => any>> = T;
+/**
+ * Vue injection key type
+ */
+type VueInjectionKey<_T> = symbol | string;
+/**
+ * Vue provide/inject type pair
+ */
+interface VueProvideInjectPair<T> {
+  key: VueInjectionKey<T>;
+  defaultValue?: T;
+}
+/**
+ * Vue computed property type
+ */
+interface VueComputed<T> {
+  get: () => T;
+  set?: (value: T) => void;
+}
+/**
+ * Vue ref type
+ */
+interface VueRef<T = unknown> {
+  value: T;
+}
+/**
+ * Vue reactive type
+ */
+type VueReactive<T extends object> = T;
+/**
+ * Convert Vue props options to TypeScript type
+ */
+type VuePropsToType<T extends VueRawProps> = { [K in keyof T]: T[K] extends {
+  type: infer C;
+  required: true;
+} ? C extends VuePropConstructor<infer V> ? V : never : T[K] extends {
+  type: infer C;
+  default: unknown;
+} ? C extends VuePropConstructor<infer V> ? V : never : T[K] extends VuePropConstructor<infer V> ? V | undefined : T[K] extends VuePropType<infer V> ? V | undefined : never };
+/**
+ * Vue component instance type
+ */
+interface VueComponentInstance<P = unknown, S = unknown> {
+  $props: P;
+  $slots: S;
+  $emit: (event: string, ...args: unknown[]) => void;
+}
+//#endregion
+//#region src/functions/index.d.ts
+/**
+ * Function type utilities
+ */
+/**
+ * Get function parameters as tuple
+ *
+ * @example
+ * ```ts
+ * type Fn = (a: string, b: number) => boolean
+ * Parameters<Fn>    // [string, number]
+ * ```
+ */
+type Parameters<T> = T extends ((...args: infer P) => any) ? P : never;
+/**
+ * Get function return type
+ *
+ * @example
+ * ```ts
+ * type Fn = (a: string) => number
+ * ReturnType<Fn>    // number
+ * ```
+ */
+type ReturnType$1<T> = T extends ((...args: any[]) => infer R) ? R : any;
+/**
+ * Get Nth parameter type (0-indexed)
+ *
+ * @example
+ * ```ts
+ * type Fn = (a: string, b: number, c: boolean) => void
+ * NthParameter<Fn, 0>  // string
+ * NthParameter<Fn, 1>  // number
+ * NthParameter<Fn, 2>  // boolean
+ * ```
+ */
+type NthParameter<T, N extends number> = T extends ((...args: infer P) => any) ? P[N] : never;
+/**
+ * Extract async function return type (unwraps Promise)
+ *
+ * @example
+ * ```ts
+ * type AsyncFn = () => Promise<string>
+ * AsyncReturnType<AsyncFn>  // string
+ * ```
+ */
+type AsyncReturnType<T> = T extends ((...args: any[]) => Promise<infer R>) ? R : T extends ((...args: any[]) => infer R) ? R : never;
+/**
+ * Get function this parameter type
+ *
+ * @example
+ * ```ts
+ * type Fn = (this: { x: number }) => void
+ * ThisParameterType<Fn>  // { x: number }
+ * ```
+ */
+type ThisParameterType<T> = T extends ((this: infer U, ...args: any[]) => any) ? U : unknown;
+/**
+ * Omit this parameter from function type
+ *
+ * @example
+ * ```ts
+ * type Fn = (this: { x: number }, a: string) => void
+ * OmitThisParameter<Fn>  // (a: string) => void
+ * ```
+ */
+type OmitThisParameter<T> = T extends ((this: any, ...args: infer A) => infer R) ? (...args: A) => R : T;
+/**
+ * Check if type is a function
+ *
+ * @example
+ * ```ts
+ * IsFunction<() => void>  // true
+ * IsFunction<string>      // false
+ * ```
+ */
+type IsFunction<T> = T extends ((...args: any[]) => any) ? true : false;
+/**
+ * Check if type is an async function
+ *
+ * @example
+ * ```ts
+ * IsAsyncFunction<() => Promise<string>>  // true
+ * IsAsyncFunction<() => string>           // false
+ * ```
+ */
+type IsAsyncFunction<T> = T extends ((...args: any[]) => Promise<any>) ? true : false;
+/**
+ * Make function parameters optional
+ *
+ * @example
+ * ```ts
+ * type Fn = (a: string, b: number) => void
+ * OptionalParameters<Fn>  // (a?: string, b?: number) => void
+ * ```
+ */
+type OptionalParameters<T> = T extends ((...args: any[]) => infer R) ? (...args: Partial<Parameters<T>>) => R : never;
+/**
+ * Append a parameter to a function
+ *
+ * @example
+ * ```ts
+ * type Fn = (a: string) => void
+ * AppendParameter<Fn, number>  // (a: string, b: number) => void
+ * ```
+ */
+type AppendParameter<T, P> = T extends ((...args: infer A) => infer R) ? (...args: [...A, P]) => R : never;
+/**
+ * Prepend a parameter to a function
+ *
+ * @example
+ * ```ts
+ * type Fn = (a: string) => void
+ * PrependParameter<Fn, number>  // (a: number, b: string) => void
+ * ```
+ */
+type PrependParameter<T, P> = T extends ((...args: infer A) => infer R) ? (...args: [P, ...A]) => R : never;
+//#endregion
+//#region src/guards/index.d.ts
+/**
+ * Check if type is an array
+ *
+ * @example
+ * ```ts
+ * IsArray<string[]> // true
+ * IsArray<string>   // false
+ * ```
+ */
+type IsArray<T> = T extends readonly unknown[] ? T extends readonly [...unknown[]] ? true : false : false;
+/**
+ * Check if type is a tuple
+ *
+ * @example
+ * ```ts
+ * IsTuple<[string, number]> // true
+ * IsTuple<string[]>         // false
+ * ```
+ */
+type IsTuple<T> = T extends readonly [unknown, ...unknown[]] ? T extends readonly unknown[] ? number extends T['length'] ? false : true : false : false;
+/**
+ * Check if two types are equal
+ *
+ * @example
+ * ```ts
+ * IsEqual<string, string>   // true
+ * IsEqual<string, number>   // false
+ * ```
+ */
+type IsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+/**
+ * Check if type is any
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Check if type is never
+ */
+type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Check if type is unknown
+ */
+type IsUnknown<T> = IsEqual<T, unknown> extends true ? IsAny<T> extends true ? false : true : false;
+//#endregion
+//#region src/infer/index.d.ts
+/**
+ * Get Promise value type (recursive unwrapping)
+ *
+ * @example
+ * ```ts
+ * Awaited<Promise<string>>        // string
+ * Awaited<Promise<Promise<number>>> // number
+ * ```
+ */
+type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
+/**
+ * Get array element type
+ *
+ * @example
+ * ```ts
+ * ArrayElement<string[]>  // string
+ * ArrayElement<(number | boolean)[]> // number | boolean
+ * ```
+ */
+type ArrayElement<T> = T extends readonly (infer E)[] ? E : never;
+/**
+ * Get object value type
+ *
+ * @example
+ * ```ts
+ * ValueOf<{ a: string; b: number }> // string | number
+ * ```
+ */
+type ValueOf<T> = T[keyof T];
+/**
+ * Get function type keys
+ *
+ * @example
+ * ```ts
+ * interface Obj {
+ *   name: string
+ *   onClick: () => void
+ *   onChange: (v: string) => void
+ * }
+ * FunctionKeys<Obj> // 'onClick' | 'onChange'
+ * ```
+ */
+type FunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
+/**
+ * Get non-function type keys
+ *
+ * @example
+ * ```ts
+ * interface Obj {
+ *   name: string
+ *   onClick: () => void
+ * }
+ * NonFunctionKeys<Obj> // 'name'
+ * ```
+ */
+type NonFunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? never : K }[keyof T];
+/**
+ * Get function's first parameter type
+ */
+type FirstParameter<T> = T extends ((first: infer F, ...rest: any[]) => any) ? F : never;
+/**
+ * Extract function properties
+ */
+type FunctionOnly<T> = Pick<T, FunctionKeys<T>>;
+/**
+ * Extract non-function properties
+ */
+type DataOnly<T> = Pick<T, NonFunctionKeys<T>>;
+//#endregion
+//#region src/utils/index.d.ts
+/**
+ * Merge two types (latter overrides former)
+ *
+ * @example
+ * ```ts
+ * Merge<{ a: string; b: number }, { b: boolean; c: string }>
+ * // { a: string; b: boolean; c: string }
+ * ```
+ */
+type Merge<T, U> = Omit<T, keyof U> & U;
+/**
+ * Non null/undefined
+ *
+ * @example
+ * ```ts
+ * NonNullable<string | null | undefined> // string
+ * ```
+ */
+type NonNullable$1<T> = T & {};
+/**
+ * Exclusive properties (only one can be selected)
+ *
+ * @example
+ * ```ts
+ * type Result = Exclusive<{ type: 'a'; valueA: string } | { type: 'b'; valueB: number }, 'type'>
+ * // Only type: 'a' or type: 'b' can be selected
+ * ```
+ */
+type Exclusive<T, K extends keyof T> = T extends unknown ? Omit<T, K> & { [P in K]?: never } : never;
+/**
+ * Remove null and undefined from all properties
+ */
+type NoNullish<T> = { [K in keyof T]: NonNullable$1<T[K]> };
+/**
+ * Make all properties optional while preserving undefined/null values
+ */
+type LoosePartial<T> = { [P in keyof T]?: T[P] };
+/**
+ * Literal types
+ */
+type Literal = string | number | boolean | undefined | null | void | bigint;
+/**
+ * Exact literal types
+ */
+type LiteralString<T extends string> = T;
+type LiteralNumber<T extends number> = T;
+type LiteralBoolean<T extends boolean> = T;
+/**
+ * Nullable type
+ */
+type Nullable<T> = T | null;
+/**
+ * Optional type
+ */
+type Optional<T> = T | undefined;
+/**
+ * Maybe type (nullable and optional)
+ */
+type Maybe<T> = T | null | undefined;
+/**
+ * Convert string to camelCase
+ */
+type CamelCase<S extends string> = S extends `${infer P}_${infer Q}` ? `${P}${Capitalize<CamelCase<Q>>}` : S extends `${infer P}-${infer Q}` ? `${P}${Capitalize<CamelCase<Q>>}` : S;
+/**
+ * Convert object keys to camelCase
+ */
+type CamelCaseKeys<T> = { [K in keyof T as CamelCase<string & K>]: T[K] };
+/**
+ * Convert string to snake_case
+ * Handles consecutive uppercase letters correctly (e.g., XMLParser -> xml_parser)
+ */
+type SnakeCase<S extends string> = S extends `${infer C0}${infer C1}${infer Rest}` ? C0 extends Uppercase<C0> ? C0 extends Lowercase<C0> ? `${C0}${SnakeCase<`${C1}${Rest}`>}` : C1 extends Uppercase<C1> ? C1 extends Lowercase<C1> ? `_${Lowercase<C0>}${SnakeCase<`${C1}${Rest}`>}` : `${Lowercase<C0>}${SnakeCase<`${C1}${Rest}`>}` : `_${Lowercase<C0>}${SnakeCase<`${C1}${Rest}`>}` : `${C0}${SnakeCase<`${C1}${Rest}`>}` : S extends `${infer C}` ? C extends Uppercase<C> ? C extends Lowercase<C> ? `${C}` : `_${Lowercase<C>}` : `${C}` : S;
+/**
+ * Convert object keys to snake_case
+ */
+type SnakeCaseKeys<T> = { [K in keyof T as SnakeCase<string & K>]: T[K] };
+/**
+ * Require at least one property
+ */
+type AtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & { [K in Keys]: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>> }[Keys];
+/**
+ * Strict extract
+ */
+type StrictExtract<T, U extends keyof any> = T extends Record<U, any> ? T : never;
+/**
+ * Strict exclude
+ */
+type StrictExclude<T, U extends T> = T extends U ? never : T;
+/**
+ * Convert union type to intersection type
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Convert union type to tuple
+ */
+type UnionToTuple<T> = UnionToIntersection<T extends unknown ? (t: T) => T : never> extends ((_: any) => infer W) ? [...UnionToTuple<Exclude<T, W>>, W] : [];
+/**
+ * Get all required keys of a type
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
+ *   age?: number
+ * }
+ * RequiredKeys<User> // 'name'
+ * ```
+ */
+type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
+/**
+ * Get all optional keys of a type
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
+ *   age?: number
+ * }
+ * OptionalKeys<User> // 'age'
+ * ```
+ */
+type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];
+/**
+ * Get all writable (non-readonly) keys of a type
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
  *   readonly age: number
  * }
  * WritableKeys<User> // 'name'
@@ -950,127 +1715,431 @@ type Subtract<A extends number, B extends number> = NumberToArray<B> extends [..
  */
 type Range<From extends number, To extends number, Acc extends number = From> = From extends To ? Acc : From extends To ? Acc : never;
 /**
- * Check if A is greater than B
+ * Check if A is greater than B
+ *
+ * @example
+ * ```ts
+ * GreaterThan<5, 3>  // true
+ * GreaterThan<3, 5>  // false
+ * ```
+ */
+type GreaterThan<A extends number, B extends number> = Subtract<A, B> extends 0 ? false : true;
+/**
+ * Check if A is less than B
+ *
+ * @example
+ * ```ts
+ * LessThan<3, 5>  // true
+ * LessThan<5, 3>  // false
+ * ```
+ */
+type LessThan<A extends number, B extends number> = Subtract<B, A> extends 0 ? false : true;
+/**
+ * Maximum of two numbers
+ *
+ * @example
+ * ```ts
+ * Max<3, 5>  // 5
+ * Max<5, 3>  // 5
+ * ```
+ */
+type Max<A extends number, B extends number> = GreaterThan<A, B> extends true ? A : B;
+/**
+ * Minimum of two numbers
+ *
+ * @example
+ * ```ts
+ * Min<3, 5>  // 3
+ * Min<5, 3>  // 3
+ * ```
+ */
+type Min<A extends number, B extends number> = LessThan<A, B> extends true ? A : B;
+//#endregion
+//#region src/path/index.d.ts
+/**
+ * Enhanced path utilities with validation and array support
+ */
+type Primitive = string | number | boolean | null | undefined | symbol | bigint | Date | RegExp;
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+/**
+ * Check if a path exists in type T
+ *
+ * @example
+ * ```ts
+ * interface Obj {
+ *   a: {
+ *     b: string
+ *   }
+ * }
+ *
+ * ValidPath<Obj, 'a.b'>   // true
+ * ValidPath<Obj, 'a.c'>   // false
+ * ```
+ */
+type ValidPath<T, P extends string> = T extends Primitive ? P extends '' ? true : false : P extends '' ? true : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? ValidPath<T[K], Rest> : false : P extends keyof T ? true : false;
+/**
+ * Get all paths including array indices
+ *
+ * @example
+ * ```ts
+ * interface Users {
+ *   users: { name: string }[]
+ * }
+ *
+ * ArrayPaths<Users>
+ * // 'users' | `users.${number}` | `users.${number}.name`
+ * ```
+ */
+type ArrayPaths<T, D extends number = 10> = [D] extends [never] ? never : T extends Primitive ? never : T extends readonly (infer E)[] ? ArrayPaths<E, Prev[D]> extends infer P ? P extends string ? `${number}` | `${number}.${P}` : `${number}` : `${number}` : { [K in keyof T]: T[K] extends readonly unknown[] ? `${K & string}` | `${K & string}.${ArrayPaths<T[K], Prev[D]>}` : T[K] extends Primitive ? `${K & string}` : `${K & string}` | `${K & string}.${ArrayPaths<T[K], Prev[D]>}` }[keyof T];
+/**
+ * Get leaf node paths only (paths to primitive values)
+ *
+ * @example
+ * ```ts
+ * interface Users {
+ *   users: { name: string, age: number }[]
+ * }
+ *
+ * LeafPaths<Users>
+ * // `users.${number}.name` | `users.${number}.age`
+ * ```
+ */
+type LeafPaths<T, D extends number = 10> = [D] extends [never] ? never : T extends Primitive ? never : T extends readonly (infer E)[] ? LeafPaths<E, Prev[D]> extends infer P ? P extends string ? `${number}.${P}` : never : never : { [K in keyof T]: T[K] extends Primitive ? `${K & string}` : LeafPaths<T[K], Prev[D]> extends never ? never : `${K & string}.${LeafPaths<T[K], Prev[D]>}` }[keyof T];
+/**
+ * Get the length of a path (number of segments)
+ *
+ * @example
+ * ```ts
+ * PathLength<'a.b.c'>  // 3
+ * PathLength<'single'> // 1
+ * ```
+ */
+type PathLength<P extends string> = P extends '' ? 0 : P extends `${string}.${infer Rest}` ? Increment<PathLength<Rest>> : 1;
+type Increment<N extends number, Arr extends 0[] = []> = N extends Arr['length'] ? [...Arr, 0]['length'] : Increment<N, [...Arr, 0]>;
+/**
+ * Get the parent path of a given path
+ *
+ * @example
+ * ```ts
+ * ParentPath<'a.b.c'>  // 'a.b'
+ * ParentPath<'a'>      // ''
+ * ```
+ */
+type ParentPath<P extends string> = P extends `${infer Head}.${infer _}` ? Head : '';
+/**
+ * Get the last segment of a path
+ *
+ * @example
+ * ```ts
+ * PathLeaf<'a.b.c'>  // 'c'
+ * PathLeaf<'a'>      // 'a'
+ * ```
+ */
+type PathLeaf<P extends string> = P extends `${string}.${infer Tail}` ? PathLeaf<Tail> : P;
+//#endregion
+//#region src/perf/cache.d.ts
+/**
+ * Type caching utilities
+ *
+ * These types help cache and memoize type computations.
+ */
+/**
+ * Cached type - prevents re-computation
+ *
+ * @example
+ * ```ts
+ * type CachedResult = Cached<ComplexComputation>
+ * ```
+ */
+type Cached<T> = T extends infer U ? {
+  __cached: U;
+} : never;
+/**
+ * Extract cached value
+ *
+ * @example
+ * ```ts
+ * type Value = CachedValue<Cached<string>>  // string
+ * ```
+ */
+type CachedValue<T> = T extends {
+  __cached: infer U;
+} ? U : never;
+/**
+ * Memoized type - remembers computation
+ *
+ * @example
+ * ```ts
+ * type Memo = Memoized<{ a: string } & { b: number }>
+ * ```
+ */
+type Memoized<T> = T extends infer U ? U : never;
+/**
+ * Type identity - prevents structural typing
+ */
+interface TypeIdentity<T> {
+  __brand: T;
+}
+/**
+ * Brand cache for memoization
+ */
+type BrandCache<T, B extends string> = T & {
+  __brandCache: B;
+};
+/**
+ * Resolve brand cache
+ */
+type ResolveBrandCache<T> = T extends {
+  __brandCache: infer _;
+} ? Omit<T, '__brandCache'> : T;
+/**
+ * Cached intersection
+ */
+type CachedIntersection<A, B> = Cached<A & B>;
+/**
+ * Cached union
+ */
+type CachedUnion<A, B> = Cached<A | B>;
+/**
+ * Cached keyof
+ */
+type CachedKeyOf<T> = Cached<keyof T>;
+/**
+ * Cached property access
+ */
+type CachedProperty<T, K extends keyof T> = Cached<T[K]>;
+/**
+ * Type computation cache key
+ */
+type CacheKey<T> = symbol & {
+  __cacheKey: T;
+};
+/**
+ * Cache entry
+ */
+interface CacheEntry<K, V> {
+  key: K;
+  value: V;
+  timestamp: number;
+}
+/**
+ * Type cache structure
+ */
+type TypeCache<T extends Record<string, unknown>> = { [K in keyof T]: Cached<T[K]> };
+/**
+ * Flush cache - force re-computation
+ */
+type FlushCache<T> = T extends Cached<infer U> ? U : T;
+//#endregion
+//#region src/perf/lazy.d.ts
+/**
+ * Lazy type evaluation utilities
+ *
+ * These types help defer type evaluation for better compilation performance.
+ */
+/**
+ * Lazy type wrapper - defers type evaluation
+ *
+ * @example
+ * ```ts
+ * // Instead of complex immediate evaluation
+ * type Result = Lazy<ComplexUnion>
+ * ```
+ */
+type Lazy<T> = () => T;
+/**
+ * Force evaluate a lazy type
+ *
+ * @example
+ * ```ts
+ * type Deferred = Lazy<string>
+ * type Evaluated = ForceEvaluate<Deferred>  // string
+ * ```
+ */
+type ForceEvaluate<T> = T extends (() => infer R) ? R : T;
+/**
+ * Deferred type - prevents immediate expansion
  *
  * @example
  * ```ts
- * GreaterThan<5, 3>  // true
- * GreaterThan<3, 5>  // false
+ * type Complex = Deferred<{ a: string } & { b: number }>
  * ```
  */
-type GreaterThan<A extends number, B extends number> = Subtract<A, B> extends 0 ? false : true;
+type Deferred<T> = T extends infer U ? U : never;
 /**
- * Check if A is less than B
+ * Thunk type - zero-argument function returning a type
  *
  * @example
  * ```ts
- * LessThan<3, 5>  // true
- * LessThan<5, 3>  // false
+ * type StringThunk = Thunk<string>
+ * // () => string
  * ```
  */
-type LessThan<A extends number, B extends number> = Subtract<B, A> extends 0 ? false : true;
+type Thunk<T> = () => T;
 /**
- * Maximum of two numbers
+ * Lazy property access
  *
  * @example
  * ```ts
- * Max<3, 5>  // 5
- * Max<5, 3>  // 5
+ * type Props = { a: string; b: number; c: boolean }
+ * type LazyA = LazyKey<Props, 'a'>  // () => Props['a']
  * ```
  */
-type Max<A extends number, B extends number> = GreaterThan<A, B> extends true ? A : B;
+type LazyKey<T, K extends keyof T> = () => T[K];
 /**
- * Minimum of two numbers
+ * Lazy conditional - defers conditional evaluation
  *
  * @example
  * ```ts
- * Min<3, 5>  // 3
- * Min<5, 3>  // 3
+ * type Cond = LazyConditional<true, string, number>
+ * // () => string
  * ```
  */
-type Min<A extends number, B extends number> = LessThan<A, B> extends true ? A : B;
+type LazyConditional<C extends boolean, T, F> = C extends true ? () => T : () => F;
+/**
+ * Lazy array element
+ */
+type LazyArrayElement<T> = T extends readonly (infer E)[] ? () => E : never;
+/**
+ * Lazy promise unwrap
+ */
+type LazyAwaited<T> = T extends PromiseLike<infer U> ? () => U : () => T;
+/**
+ * Lazy function return
+ */
+type LazyReturnType<T> = T extends ((...args: any[]) => infer R) ? () => R : never;
+/**
+ * Lazy function parameters
+ */
+type LazyParameters<T> = T extends ((...args: infer P) => any) ? () => P : never;
+/**
+ * Chain lazy evaluations
+ */
+type LazyChain<T, F extends (value: T) => unknown> = () => ReturnType<F>;
+/**
+ * Lazy map over array type
+ */
+type LazyMap<T extends readonly unknown[], F extends (value: T[number]) => unknown> = { [K in keyof T]: () => ReturnType<F> };
 //#endregion
-//#region src/path/index.d.ts
+//#region src/perf/optimize.d.ts
 /**
- * Enhanced path utilities with validation and array support
+ * Type optimization utilities
+ *
+ * These types help simplify and optimize complex types for better compilation.
  */
-type Primitive = string | number | boolean | null | undefined | symbol | bigint | Date | RegExp;
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
 /**
- * Check if a path exists in type T
+ * Simplify complex types - flatten intersections
  *
  * @example
  * ```ts
- * interface Obj {
- *   a: {
- *     b: string
- *   }
- * }
- *
- * ValidPath<Obj, 'a.b'>   // true
- * ValidPath<Obj, 'a.c'>   // false
+ * type Complex = { a: string } & { b: number }
+ * type Simple = Simplify<Complex>
+ * // { a: string; b: number }
  * ```
  */
-type ValidPath<T, P extends string> = T extends Primitive ? P extends '' ? true : false : P extends '' ? true : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? ValidPath<T[K], Rest> : false : P extends keyof T ? true : false;
+type Simplify<T> = { [K in keyof T]: T[K] } & unknown;
 /**
- * Get all paths including array indices
+ * Deep simplify - recursively flatten types
  *
  * @example
  * ```ts
- * interface Users {
- *   users: { name: string }[]
- * }
+ * type Nested = { a: { b: string } & { c: number } }
+ * type Deep = DeepSimplify<Nested>
+ * ```
+ */
+type DeepSimplify<T> = T extends object ? T extends ((...args: any[]) => any) ? T : T extends Array<infer E> ? DeepSimplify<E>[] : { [K in keyof T]: DeepSimplify<T[K]> } : T;
+/**
+ * Flatten type - remove extra intersections
  *
- * ArrayPaths<Users>
- * // 'users' | `users.${number}` | `users.${number}.name`
+ * @example
+ * ```ts
+ * type Flat = FlattenType<{ a: string } & { b: number } & { c: boolean }>
+ * // { a: string; b: number; c: boolean }
  * ```
  */
-type ArrayPaths<T, D extends number = 10> = [D] extends [never] ? never : T extends Primitive ? never : T extends readonly (infer E)[] ? ArrayPaths<E, Prev[D]> extends infer P ? P extends string ? `${number}` | `${number}.${P}` : `${number}` : `${number}` : { [K in keyof T]: T[K] extends readonly unknown[] ? `${K & string}` | `${K & string}.${ArrayPaths<T[K], Prev[D]>}` : T[K] extends Primitive ? `${K & string}` : `${K & string}` | `${K & string}.${ArrayPaths<T[K], Prev[D]>}` }[keyof T];
+type FlattenType<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
 /**
- * Get leaf node paths only (paths to primitive values)
+ * Reduce intersection - simplify intersection types
  *
  * @example
  * ```ts
- * interface Users {
- *   users: { name: string, age: number }[]
- * }
+ * type Reduced = ReduceIntersection<{ a: string } & { a: string; b: number }>
+ * // { a: string; b: number }
+ * ```
+ */
+type ReduceIntersection<T> = T extends infer U ? Simplify<U> : never;
+/**
+ * Reduce union - remove duplicate union members
  *
- * LeafPaths<Users>
- * // `users.${number}.name` | `users.${number}.age`
+ * @example
+ * ```ts
+ * type Reduced = ReduceUnion<string | number | string>
+ * // string | number
  * ```
  */
-type LeafPaths<T, D extends number = 10> = [D] extends [never] ? never : T extends Primitive ? never : T extends readonly (infer E)[] ? LeafPaths<E, Prev[D]> extends infer P ? P extends string ? `${number}.${P}` : never : never : { [K in keyof T]: T[K] extends Primitive ? `${K & string}` : LeafPaths<T[K], Prev[D]> extends never ? never : `${K & string}.${LeafPaths<T[K], Prev[D]>}` }[keyof T];
+type ReduceUnion<T> = T extends infer U ? U : never;
 /**
- * Get the length of a path (number of segments)
+ * Compact type - remove never and undefined from objects
  *
  * @example
  * ```ts
- * PathLength<'a.b.c'>  // 3
- * PathLength<'single'> // 1
+ * type Compacted = Compact<{ a: string; b: never; c?: undefined }>
+ * // { a: string }
  * ```
  */
-type PathLength<P extends string> = P extends '' ? 0 : P extends `${string}.${infer Rest}` ? Increment<PathLength<Rest>> : 1;
-type Increment<N extends number, Arr extends 0[] = []> = N extends Arr['length'] ? [...Arr, 0]['length'] : Increment<N, [...Arr, 0]>;
+type Compact<T> = { [K in keyof T as T[K] extends never ? never : undefined extends T[K] ? never : K]: T[K] };
 /**
- * Get the parent path of a given path
+ * Strip never from object
  *
  * @example
  * ```ts
- * ParentPath<'a.b.c'>  // 'a.b'
- * ParentPath<'a'>      // ''
+ * type Stripped = StripNever<{ a: string; b: never; c: number }>
+ * // { a: string; c: number }
  * ```
  */
-type ParentPath<P extends string> = P extends `${infer Head}.${infer _}` ? Head : '';
+type StripNever<T> = { [K in keyof T as T[K] extends never ? never : K]: T[K] };
 /**
- * Get the last segment of a path
+ * Strip undefined from object
  *
  * @example
  * ```ts
- * PathLeaf<'a.b.c'>  // 'c'
- * PathLeaf<'a'>      // 'a'
+ * type Stripped = StripUndefined<{ a: string; b?: undefined; c: number }>
+ * // { a: string; c: number }
  * ```
  */
-type PathLeaf<P extends string> = P extends `${string}.${infer Tail}` ? PathLeaf<Tail> : P;
+type StripUndefined<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K] };
+/**
+ * Strip null from object
+ */
+type StripNull<T> = { [K in keyof T as null extends T[K] ? never : K]: T[K] };
+/**
+ * Merge all - deeply merge object types
+ */
+type MergeAll<T extends object[]> = T extends [infer First extends object, ...infer Rest extends object[]] ? Rest extends [] ? Simplify<First> : Simplify<First & MergeAll<Rest>> : Record<string, never>;
+/**
+ * Pick non-nullable - pick only non-nullable properties
+ */
+type PickNonNullable<T> = { [K in keyof T as null | undefined extends T[K] ? never : K]: T[K] };
+/**
+ * Pick nullable - pick only nullable properties
+ */
+type PickNullable<T> = { [K in keyof T as null | undefined extends T[K] ? K : never]: T[K] };
+/**
+ * Type equivalence check (optimized)
+ */
+type TypeEq<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+/**
+ * Exact type - ensure exact shape match
+ */
+type ExactType<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? T : never : never;
+/**
+ * Normalize - remove optional markers while preserving types
+ */
+type Normalize<T> = { [K in keyof T]-?: T[K] };
+/**
+ * Optionalize - make all properties optional
+ */
+type Optionalize<T> = { [K in keyof T]?: T[K] };
 //#endregion
 //#region src/record/index.d.ts
 /**
@@ -1181,6 +2250,569 @@ type HasKeys<T, K extends keyof any> = K extends keyof T ? T : never;
  */
 type HasExactKeys<T, K extends keyof any> = keyof T extends K ? K extends keyof T ? true : false : false;
 //#endregion
+//#region src/schema/runtime.d.ts
+/**
+ * Runtime type checking utilities
+ */
+/**
+ * Runtime type guard function type
+ *
+ * @example
+ * ```ts
+ * const isString: RuntimeGuard<string> = (value): value is string =>
+ *   typeof value === 'string'
+ * ```
+ */
+type RuntimeGuard<T> = (value: unknown) => value is T;
+/**
+ * Extract the guarded type from a type guard function
+ *
+ * @example
+ * ```ts
+ * const isNumber = (value: unknown): value is number => typeof value === 'number'
+ * type Num = GuardedType<typeof isNumber>  // number
+ * ```
+ */
+type GuardedType<G> = G extends ((value: unknown) => value is infer T) ? T : never;
+/**
+ * Check if a type has a runtime check function
+ *
+ * @example
+ * ```ts
+ * type A = HasRuntimeCheck<string>  // true (typeof check)
+ * type B = HasRuntimeCheck<object>  // false (no direct check)
+ * ```
+ */
+type HasRuntimeCheck<T> = T extends string | number | boolean | symbol | bigint | null | undefined ? true : T extends Array<infer _> ? true : T extends Map<infer _, infer _> ? true : T extends Set<infer _> ? true : T extends Date ? true : false;
+/**
+ * Primitive type guard mapping
+ */
+interface PrimitiveGuardMap {
+  string: (value: unknown) => value is string;
+  number: (value: unknown) => value is number;
+  boolean: (value: unknown) => value is boolean;
+  symbol: (value: unknown) => value is symbol;
+  bigint: (value: unknown) => value is bigint;
+  null: (value: unknown) => value is null;
+  undefined: (value: unknown) => value is undefined;
+}
+/**
+ * Get primitive guard type
+ */
+type PrimitiveGuard<T extends keyof PrimitiveGuardMap> = PrimitiveGuardMap[T];
+/**
+ * Composite type guard for objects
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
+ *   age: number
+ * }
+ *
+ * const isUser: CompositeGuard<User> = (value): value is User => {
+ *   return typeof value === 'object' && value !== null &&
+ *     'name' in value && 'age' in value
+ * }
+ * ```
+ */
+type CompositeGuard<T extends object> = (value: unknown) => value is T;
+/**
+ * Array element guard
+ */
+type ArrayElementGuard<T> = (value: unknown) => value is T[];
+/**
+ * Create a type guard that checks for null
+ */
+type NullGuard = RuntimeGuard<null>;
+/**
+ * Create a type guard that checks for undefined
+ */
+type UndefinedGuard = RuntimeGuard<undefined>;
+/**
+ * Create a type guard that checks for null or undefined
+ */
+type NullishGuard = RuntimeGuard<null | undefined>;
+/**
+ * Negate a type guard
+ *
+ * @example
+ * ```ts
+ * const isNotString: NegateGuard<string> = (value): value is Exclude<unknown, string> =>
+ *   typeof value !== 'string'
+ * ```
+ */
+type NegateGuard<T> = (value: unknown) => value is Exclude<unknown, T>;
+/**
+ * Combine multiple type guards (AND)
+ */
+type CombinedGuard<T, U> = (value: unknown) => value is T & U;
+/**
+ * Union type guard (OR)
+ */
+type UnionGuard<T, U> = (value: unknown) => value is T | U;
+/**
+ * Type predicate helper
+ */
+type TypePredicate = (value: unknown) => boolean;
+/**
+ * Assertion function type
+ */
+type AssertionFunction<T> = (value: unknown) => asserts value is T;
+/**
+ * Convert type to guard name mapping
+ */
+type TypeToGuardKey<T> = T extends string ? 'string' : T extends number ? 'number' : T extends boolean ? 'boolean' : T extends symbol ? 'symbol' : T extends bigint ? 'bigint' : T extends null ? 'null' : T extends undefined ? 'undefined' : never;
+/**
+ * Type guard for any value
+ */
+type AnyGuard = RuntimeGuard<unknown>;
+//#endregion
+//#region src/schema/yup.d.ts
+/**
+ * Yup schema integration types
+ *
+ * These types work with Yup schemas to provide type extraction and manipulation.
+ * Note: Yup is an optional peer dependency.
+ */
+declare const YupTypeSymbol: unique symbol;
+/**
+ * Base Yup schema type stub
+ */
+interface YupSchemaStub<T = unknown> {
+  [YupTypeSymbol]?: T;
+}
+/**
+ * Extract the output type from a Yup schema
+ *
+ * @example
+ * ```ts
+ * import * as yup from 'yup'
+ *
+ * const UserSchema = yup.object({
+ *   name: yup.string().required(),
+ *   age: yup.number()
+ * })
+ *
+ * type User = YupOutput<typeof UserSchema>
+ * // { name: string; age?: number | undefined }
+ * ```
+ */
+type YupOutput<T> = T extends {
+  __outputType: infer O;
+} ? O : T extends {
+  spec: object;
+} ? T : never;
+/**
+ * Extract the input type from a Yup schema
+ *
+ * @example
+ * ```ts
+ * import * as yup from 'yup'
+ *
+ * const UserSchema = yup.object({
+ *   name: yup.string().required(),
+ *   age: yup.number()
+ * })
+ *
+ * type UserInput = YupInput<typeof UserSchema>
+ * // { name: string; age?: number | undefined }
+ * ```
+ */
+type YupInput<T> = T extends {
+  __inputType: infer I;
+} ? I : T extends {
+  spec: object;
+} ? T : never;
+/**
+ * Check if a type is a Yup schema
+ *
+ * @example
+ * ```ts
+ * import * as yup from 'yup'
+ *
+ * type A = IsYupSchema<yup.StringSchema>  // true
+ * type B = IsYupSchema<string>            // false
+ * ```
+ */
+type IsYupSchema<T> = T extends {
+  spec: object;
+} ? true : T extends {
+  __isYupSchema: true;
+} ? true : false;
+/**
+ * Extract the inner type from Yup optional schema
+ */
+type YupUnwrapOptional<T> = T extends {
+  _innerType: infer I;
+} ? I : T;
+/**
+ * Check if Yup schema is optional
+ */
+type IsYupOptional<T> = T extends {
+  spec: {
+    optional: true;
+  };
+} ? true : T extends {
+  _nullable: true;
+} ? true : false;
+/**
+ * Check if Yup schema is nullable
+ */
+type IsYupNullable<T> = T extends {
+  spec: {
+    nullable: true;
+  };
+} ? true : T extends {
+  _nullable: true;
+} ? true : false;
+/**
+ * Get the element type from Yup array schema
+ */
+type YupArrayElement<T> = T extends {
+  _subType: infer E;
+} ? E : T extends {
+  innerType: infer E;
+} ? E : never;
+/**
+ * Convert Yup schema to TypeScript type (alias for YupOutput)
+ */
+type YupToType<T> = YupOutput<T>;
+/**
+ * Get Yup schema fields from object schema
+ */
+type YupFields<T> = T extends {
+  fields: infer F;
+} ? F : T extends {
+  _subFields: infer F;
+} ? F : never;
+/**
+ * Required keys from Yup object schema
+ */
+type YupRequiredKeys<T> = T extends {
+  fields: infer F;
+} ? { [K in keyof F]: F[K] extends {
+  spec: {
+    optional: true;
+  };
+} ? never : F[K] extends {
+  _optional: true;
+} ? never : K }[keyof F] : never;
+/**
+ * Optional keys from Yup object schema
+ */
+type YupOptionalKeys<T> = T extends {
+  fields: infer F;
+} ? { [K in keyof F]: F[K] extends {
+  spec: {
+    optional: true;
+  };
+} ? K : F[K] extends {
+  _optional: true;
+} ? K : never }[keyof F] : never;
+/**
+ * Yup schema type names
+ */
+type YupTypeNames = 'StringSchema' | 'NumberSchema' | 'BooleanSchema' | 'DateSchema' | 'ArraySchema' | 'ObjectSchema' | 'MixedSchema' | 'TupleSchema' | 'Lazy';
+/**
+ * Yup validation error type
+ */
+interface YupErrorType {
+  name: 'ValidationError';
+  value: unknown;
+  path: string;
+  type: string | undefined;
+  errors: string[];
+  inner: Array<{
+    name: 'ValidationError';
+    path: string;
+    message: string;
+    type: string | undefined;
+  }>;
+}
+/**
+ * Yup test config type
+ */
+interface YupTestConfig<T = unknown> {
+  name: string;
+  message: string | ((params: {
+    value: unknown;
+    path: string;
+  }) => string);
+  test: (value: T) => boolean | Promise<boolean>;
+}
+/**
+ * Yup transform function type
+ */
+type YupTransform<T = unknown, R = unknown> = (value: T, originalValue: T) => R;
+//#endregion
+//#region src/schema/zod.d.ts
+/**
+ * Zod schema integration types
+ *
+ * These types work with Zod schemas to provide type extraction and manipulation.
+ * Note: Zod is an optional peer dependency.
+ */
+declare const ZodTypeSymbol: unique symbol;
+/**
+ * Base Zod schema type stub
+ */
+interface ZodTypeStub<T = unknown> {
+  [ZodTypeSymbol]?: T;
+}
+/**
+ * ZodObject shape stub
+ */
+type ZodObjectShapeStub = Record<string, ZodTypeStub>;
+/**
+ * Extract the output type from a Zod schema
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const UserSchema = z.object({
+ *   name: z.string(),
+ *   age: z.number()
+ * })
+ *
+ * type User = ZodOutput<typeof UserSchema>
+ * // { name: string; age: number }
+ * ```
+ */
+type ZodOutput<T> = T extends {
+  _output: infer O;
+} ? O : T extends {
+  _def: {
+    type: string;
+  };
+} ? T : never;
+/**
+ * Extract the input type from a Zod schema
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const UserSchema = z.object({
+ *   name: z.string(),
+ *   age: z.number().optional()
+ * })
+ *
+ * type UserInput = ZodInput<typeof UserSchema>
+ * // { name: string; age?: number | undefined }
+ * ```
+ */
+type ZodInput<T> = T extends {
+  _input: infer I;
+} ? I : T extends {
+  _def: {
+    type: string;
+  };
+} ? T : never;
+/**
+ * Check if a type is a Zod schema
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * type A = IsZodSchema<z.ZodString>  // true
+ * type B = IsZodSchema<string>       // false
+ * ```
+ */
+type IsZodSchema<T> = T extends {
+  _def: object;
+} ? true : false;
+/**
+ * Extract shape from ZodObject
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const UserSchema = z.object({
+ *   name: z.string(),
+ *   age: z.number()
+ * })
+ *
+ * type Shape = ZodShape<typeof UserSchema>
+ * // { name: ZodString; age: ZodNumber }
+ * ```
+ */
+type ZodShape<T> = T extends {
+  _def: {
+    shape: () => infer S;
+  };
+} ? S : T extends {
+  shape: infer S;
+} ? S : never;
+/**
+ * Extract the inner type from ZodOptional
+ */
+type ZodUnwrapOptional<T> = T extends {
+  _def: {
+    innerType: infer I;
+  };
+} ? I : T;
+/**
+ * Extract the inner type from ZodNullable
+ */
+type ZodUnwrapNullable<T> = T extends {
+  _def: {
+    innerType: infer I;
+  };
+} ? I : T;
+/**
+ * Check if Zod schema is optional
+ */
+type IsZodOptional<T> = T extends {
+  _def: {
+    typeName: 'ZodOptional';
+  };
+} ? true : false;
+/**
+ * Check if Zod schema is nullable
+ */
+type IsZodNullable<T> = T extends {
+  _def: {
+    typeName: 'ZodNullable';
+  };
+} ? true : false;
+/**
+ * Get the element type from ZodArray
+ */
+type ZodArrayElement<T> = T extends {
+  _def: {
+    type: 'array';
+    elementType: infer E;
+  };
+} ? E : T extends {
+  element: infer E;
+} ? E : never;
+/**
+ * Get value type from ZodRecord
+ */
+type ZodRecordValue<T> = T extends {
+  _def: {
+    valueType: infer V;
+  };
+} ? V : never;
+/**
+ * Get key and value types from ZodMap
+ */
+type ZodMapEntry<T> = T extends {
+  _def: {
+    keyType: infer K;
+    valueType: infer V;
+  };
+} ? {
+  key: K;
+  value: V;
+} : never;
+/**
+ * Convert Zod schema to TypeScript type (alias for ZodOutput)
+ */
+type ZodToType<T> = ZodOutput<T>;
+/**
+ * Deep partial input for Zod schemas
+ */
+type ZodDeepPartialInput<T> = T extends {
+  _def: {
+    typeName: 'ZodObject';
+    shape: () => infer S;
+  };
+} ? { [K in keyof S]?: ZodDeepPartialInput<S[K]> } : T extends {
+  _def: {
+    typeName: 'ZodArray';
+    elementType: infer E;
+  };
+} ? ZodDeepPartialInput<E>[] : T extends {
+  _def: {
+    typeName: 'ZodOptional';
+    innerType: infer I;
+  };
+} ? ZodDeepPartialInput<I> | undefined : T extends {
+  _def: {
+    typeName: 'ZodNullable';
+    innerType: infer I;
+  };
+} ? ZodDeepPartialInput<I> | null : T;
+/**
+ * Required keys from ZodObject schema
+ */
+type ZodRequiredKeys<T> = T extends {
+  _def: {
+    shape: () => infer S;
+  };
+} ? { [K in keyof S]: S[K] extends {
+  _def: {
+    typeName: 'ZodOptional';
+  };
+} ? never : S[K] extends {
+  _def: {
+    typeName: 'ZodDefault';
+  };
+} ? never : K }[keyof S] : never;
+/**
+ * Optional keys from ZodObject schema
+ */
+type ZodOptionalKeys<T> = T extends {
+  _def: {
+    shape: () => infer S;
+  };
+} ? { [K in keyof S]: S[K] extends {
+  _def: {
+    typeName: 'ZodOptional';
+  };
+} ? K : S[K] extends {
+  _def: {
+    typeName: 'ZodDefault';
+  };
+} ? K : never }[keyof S] : never;
+/**
+ * Pick properties from ZodObject schema
+ */
+type ZodPick<T, K extends keyof ZodShape<T>> = T extends {
+  _def: {
+    shape: () => infer S;
+  };
+} ? {
+  _def: {
+    shape: () => Pick<S, K & keyof S>;
+    typeName: 'ZodObject';
+  };
+} : never;
+/**
+ * Omit properties from ZodObject schema
+ */
+type ZodOmit<T, K extends keyof ZodShape<T>> = T extends {
+  _def: {
+    shape: () => infer S;
+  };
+} ? {
+  _def: {
+    shape: () => Omit<S, K & keyof S>;
+    typeName: 'ZodObject';
+  };
+} : never;
+/**
+ * Get the error type from ZodError
+ */
+interface ZodErrorType {
+  issues: Array<{
+    code: string;
+    message: string;
+    path: (string | number)[];
+    expected?: string;
+    received?: string;
+  }>;
+}
+/**
+ * Zod schema type name mapping
+ */
+type ZodTypeNames = 'ZodString' | 'ZodNumber' | 'ZodBoolean' | 'ZodNull' | 'ZodUndefined' | 'ZodAny' | 'ZodUnknown' | 'ZodNever' | 'ZodVoid' | 'ZodArray' | 'ZodObject' | 'ZodUnion' | 'ZodIntersection' | 'ZodTuple' | 'ZodRecord' | 'ZodMap' | 'ZodSet' | 'ZodDate' | 'ZodFunction' | 'ZodLazy' | 'ZodLiteral' | 'ZodEnum' | 'ZodNativeEnum' | 'ZodPromise' | 'ZodBranded' | 'ZodOptional' | 'ZodNullable' | 'ZodDefault' | 'ZodCatch';
+//#endregion
 //#region src/template/index.d.ts
 /**
  * Template literal type utilities for string manipulation
@@ -1317,4 +2949,4 @@ type PadStart<S extends string, N extends number, P extends string = ' '> = Stri
 type PadEnd<S extends string, N extends number, P extends string = ' '> = StringLength<S> extends N ? S : N extends number ? `${PadEnd<S, Decrement<N>, P>}${P}` : S;
 type Decrement<N extends number, Acc extends 0[] = []> = N extends 0 ? 0 : [...Acc, 0]['length'] extends N ? Acc['length'] : Decrement<N, [...Acc, 0]>;
 //#endregion
-export { Add, And, AppendParameter, ArrayElement, ArrayPaths, Assert, AsyncReturnType, AtLeastOne, Awaited, Brand, BrandedNumber, BrandedString, CamelCase, CamelCaseKeys, CapitalizeAll, DataOnly, Dec, DeepMutable, DeepNonNullable, DeepNullable, DeepOmit, DeepOmitPaths, DeepOptional, DeepPartial, DeepPick, DeepPickPaths, DeepReadonly, DeepRequired, DeepRequiredProperties, EndsWith, Exact, Exclusive, FilterKeys, FirstParameter, Flatten, FunctionKeys, FunctionOnly, GreaterThan, HasExactKeys, HasKeys, Head, If, Immutable, Inc, Init, IsAny, IsArray, IsAsyncFunction, IsEmptyTuple, IsEqual, IsFunction, IsNever, IsTuple, IsUnknown, Keys, KeysByValueType, Last, LeafPaths, LessThan, Literal, LiteralBoolean, LiteralNumber, LiteralString, LoosePartial, Max, Maybe, Merge, Min, Mutable, NoNullish, NonFunctionKeys, NonNullable$1 as NonNullable, Not, NthParameter, Nullable, OmitPartial, OmitRequired, OmitThisParameter, Optional, OptionalKeys, OptionalParameters, Or, PadEnd, PadStart, Parameters, ParentPath, PascalCaseKeys, PathLeaf, PathLength, PathValue, Paths, PickPartial, PickRequired, PrefixKeys, PrependParameter, Range, ReadonlyKeys, RenameKeys, Repeat, Replace, ReplaceAll, Required$1 as Required, RequiredKeys, ReturnType, Reverse, SnakeCase, SnakeCaseKeys, SplitPath, StartsWith, StrictExclude, StrictExtract, StringLength, StringToArray, Subtract, SuffixKeys, Tail$1 as Tail, ThisParameterType, Trim, TrimLeft, TrimRight, TupleLength, Unbrand, UncapitalizeAll, UnionToIntersection, UnionToTuple, ValidPath, ValueOf, WritableKeys };
+export { Add, And, AnyGuard, AppendParameter, ArrayElement, ArrayElementGuard, ArrayPaths, Assert, AssertionFunction, AsyncReturnType, AtLeastOne, Awaited, Brand, BrandCache, BrandedNumber, BrandedString, CacheEntry, CacheKey, Cached, CachedIntersection, CachedKeyOf, CachedProperty, CachedUnion, CachedValue, CamelCase, CamelCaseKeys, CapitalizeAll, ChangeEventHandler, CombinedGuard, Compact, ComponentProps, ComponentPropsWithRef, CompositeGuard, DataOnly, Dec, DeepMutable, DeepNonNullable, DeepNullable, DeepOmit, DeepOmitPaths, DeepOptional, DeepPartial, DeepPick, DeepPickPaths, DeepReadonly, DeepRequired, DeepRequiredProperties, DeepSimplify, Deferred, EndsWith, EventHandler, Exact, ExactType, Exclusive, ExtractPropTypes, ExtractVueProps, FilterKeys, FirstParameter, Flatten, FlattenType, FlushCache, FocusEventHandler, ForceEvaluate, FormEventHandler, ForwardRefProps, FunctionKeys, FunctionOnly, GreaterThan, GuardedType, HasExactKeys, HasKeys, HasRuntimeCheck, Head, If, Immutable, Inc, Init, IsAny, IsArray, IsAsyncFunction, IsEmptyTuple, IsEqual, IsFunction, IsNever, IsTuple, IsUnknown, IsYupNullable, IsYupOptional, IsYupSchema, IsZodNullable, IsZodOptional, IsZodSchema, KeyboardEventHandler, Keys, KeysByValueType, Last, Lazy, LazyArrayElement, LazyAwaited, LazyChain, LazyConditional, LazyKey, LazyMap, LazyParameters, LazyReturnType, LeafPaths, LessThan, Literal, LiteralBoolean, LiteralNumber, LiteralString, LoosePartial, Max, Maybe, Memoized, Merge, MergeAll, MergeDefaultProps, Min, MouseEventHandler, Mutable, NegateGuard, NoNullish, NonFunctionKeys, NonNullable$1 as NonNullable, Normalize, NormalizeVueProps, Not, NthParameter, NullGuard, Nullable, NullishGuard, OmitPartial, OmitRequired, OmitThisParameter, Optional, OptionalKeys, OptionalParameters, OptionalProps, OptionalVueProp, Optionalize, Or, PadEnd, PadStart, Parameters, ParentPath, PascalCaseKeys, PathLeaf, PathLength, PathValue, Paths, PickNonNullable, PickNullable, PickPartial, PickRequired, PrefixKeys, PrependParameter, PrimitiveGuard, PrimitiveGuardMap, PrismaAggregateArgs, PrismaCountArgs, PrismaCreateArgs, PrismaCreateInput, PrismaDeleteArgs, PrismaFindFirstArgs, PrismaFindManyArgs, PrismaFindUniqueArgs, PrismaGroupByArgs, PrismaInclude, PrismaModel, PrismaOrderByInput, PrismaPagination, PrismaRelationFields, PrismaScalarFields, PrismaSelect, PrismaUniqueWhere, PrismaUpdateArgs, PrismaUpdateInput, PrismaUpsertArgs, PrismaWhereInput, PropsWithChildren, PropsWithClassName, PropsWithStyle, PropsWithStyleAndClassName, PropsWithoutChildren, Range, ReadonlyKeys, ReduceIntersection, ReduceUnion, RenameKeys, Repeat, Replace, ReplaceAll, Required$1 as Required, RequiredKeys, RequiredProps, RequiredVueProp, ResolveBrandCache, ReturnType$1 as ReturnType, Reverse, RuntimeGuard, Simplify, SnakeCase, SnakeCaseKeys, SplitPath, StartsWith, StrictExclude, StrictExtract, StringLength, StringToArray, StripNever, StripNull, StripUndefined, Subtract, SuffixKeys, TRPCCallerRouter, TRPCClient, TRPCContext, TRPCErrorShape, TRPCExtractProcedureType, TRPCMergeRouters, TRPCMiddleware, TRPCMutations, TRPCProcedureBuilder, TRPCProcedureCaller, TRPCProcedureInput, TRPCProcedureOutput, TRPCProcedureType, TRPCQueries, TRPCRouterRecord, TRPCRouterShape, TRPCSubscriptions, TRPSCaller, Tail$1 as Tail, ThisParameterType, Thunk, Trim, TrimLeft, TrimRight, TupleLength, TypeCache, TypeEq, TypeIdentity, TypePredicate, TypeToGuardKey, Unbrand, UncapitalizeAll, UndefinedGuard, UnionGuard, UnionToIntersection, UnionToTuple, ValidPath, ValueOf, VueComponentInstance, VueComputed, VueEmitType, VueExpose, VueInjectionKey, VueModelProps, VuePropConstructor, VuePropType, VuePropWithDefault, VuePropsToType, VueProvideInjectPair, VueRawProps, VueReactive, VueRef, VueSlot, VueSlots, WritableKeys, YupArrayElement, YupErrorType, YupFields, YupInput, YupOptionalKeys, YupOutput, YupRequiredKeys, YupSchemaStub, YupTestConfig, YupToType, YupTransform, YupTypeNames, YupUnwrapOptional, ZodArrayElement, ZodDeepPartialInput, ZodErrorType, ZodInput, ZodMapEntry, ZodObjectShapeStub, ZodOmit, ZodOptionalKeys, ZodOutput, ZodPick, ZodRecordValue, ZodRequiredKeys, ZodShape, ZodToType, ZodTypeNames, ZodTypeStub, ZodUnwrapNullable, ZodUnwrapOptional };