uni-types 1.0.0 → 1.2.0

package/dist/index.d.mts

@@ -1,3 +1,97 @@
+//#region src/brand/index.d.ts
+/**
+ * Brand/Opaque types for nominal typing
+ */
+/**
+ * Brand a type for nominal typing
+ * Creates a unique type that cannot be accidentally mixed with other branded types
+ *
+ * @example
+ * ```ts
+ * type UserId = Brand<string, 'UserId'>
+ * type OrderId = Brand<string, 'OrderId'>
+ *
+ * const userId: UserId = 'user-123' as UserId
+ * const orderId: OrderId = 'order-456' as OrderId
+ *
+ * // These won't mix - type safety!
+ * // const wrong: OrderId = userId  // Error!
+ * ```
+ */
+type Brand<T, B extends string> = T & {
+  __brand: B;
+};
+/**
+ * Unbrand a branded type - extracts the underlying type
+ *
+ * @example
+ * ```ts
+ * type UserId = Brand<string, 'UserId'>
+ * Unbrand<UserId>  // string
+ * ```
+ */
+type Unbrand<T> = T extends Brand<infer U, infer _> ? U : T;
+/**
+ * Common branded types for convenience
+ */
+type BrandedString<B extends string> = Brand<string, B>;
+type BrandedNumber<B extends string> = Brand<number, B>;
+//#endregion
+//#region src/conditional/index.d.ts
+/**
+ * Conditional type utilities for cleaner type logic
+ */
+/**
+ * If-then-else at type level
+ *
+ * @example
+ * ```ts
+ * If<true, string, number>    // string
+ * If<false, string, number>   // number
+ * ```
+ */
+type If<C extends boolean, T, F> = C extends true ? T : F;
+/**
+ * Not operator for boolean types
+ *
+ * @example
+ * ```ts
+ * Not<true>   // false
+ * Not<false>  // true
+ * ```
+ */
+type Not<B extends boolean> = B extends true ? false : true;
+/**
+ * And operator for boolean types
+ *
+ * @example
+ * ```ts
+ * And<true, true>   // true
+ * And<true, false>  // false
+ * ```
+ */
+type And<A extends boolean, B extends boolean> = A extends true ? B : false;
+/**
+ * Or operator for boolean types
+ *
+ * @example
+ * ```ts
+ * Or<true, false>   // true
+ * Or<false, false>  // false
+ * ```
+ */
+type Or<A extends boolean, B extends boolean> = A extends true ? true : B;
+/**
+ * Type constraint assertion - ensures T extends U
+ *
+ * @example
+ * ```ts
+ * Assert<string | number, string>  // string
+ * Assert<string, number>           // never
+ * ```
+ */
+type Assert<T, U extends T> = T extends U ? T : never;
+//#endregion
 //#region src/core/omit.d.ts
 /**
  * Make all properties required except specified ones
@@ -111,7 +205,7 @@ type Last<T extends readonly unknown[]> = T extends readonly [...unknown[], infe
  * Tail<[1]> // []
  * ```
  */
-type Tail<T extends readonly unknown[]> = T extends readonly [unknown, ...infer R] ? R : [];
+type Tail$1<T extends readonly unknown[]> = T extends readonly [unknown, ...infer R] ? R : [];
 /**
  * Get all elements except the last (init)
  *
@@ -160,6 +254,109 @@ type TupleLength<T extends readonly unknown[]> = T['length'];
  */
 type IsEmptyTuple<T extends readonly unknown[]> = T extends readonly [] ? true : false;
 //#endregion
+//#region src/utils/path.d.ts
+type Primitive$1 = string | number | boolean | null | undefined | symbol | bigint;
+type Join<K, P> = K extends string | number ? P extends string | number ? `${K}${'' extends P ? '' : '.'}${P}` : never : never;
+type Prev$1 = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+/**
+ * Get all possible paths to nested properties
+ *
+ * @example
+ * ```ts
+ * interface Obj {
+ *   a: {
+ *     b: string
+ *     c: {
+ *       d: number
+ *     }
+ *   }
+ * }
+ *
+ * type P = Paths<Obj>
+ * // 'a' | 'a.b' | 'a.c' | 'a.c.d'
+ * ```
+ */
+type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends Primitive$1 ? never : { [K in keyof T]: T[K] extends Primitive$1 ? `${K & string}` : Join<K, Paths<T[K], Prev$1[D]>> }[keyof T];
+/**
+ * Get the value type at a given path
+ *
+ * @example
+ * ```ts
+ * interface Obj {
+ *   a: {
+ *     b: string
+ *   }
+ * }
+ *
+ * type V = PathValue<Obj, 'a.b'> // string
+ * ```
+ */
+type PathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
+/**
+ * Split a path string into an array
+ *
+ * @example
+ * ```ts
+ * SplitPath<'a.b.c'> // ['a', 'b', 'c']
+ * ```
+ */
+type SplitPath<S extends string, Acc extends string[] = []> = S extends `${infer H}.${infer T}` ? SplitPath<T, [...Acc, H]> : S extends `${infer H}` ? [...Acc, H] : Acc;
+//#endregion
+//#region src/deep/path.d.ts
+type PathSegments<_T, P extends string> = P extends '' ? [] : SplitPath<P>;
+/**
+ * Deep omit by path - removes properties at specified paths
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   profile: {
+ *     name: string
+ *     email: string
+ *     settings: {
+ *       theme: string
+ *       lang: string
+ *     }
+ *   }
+ * }
+ *
+ * DeepOmit<User, 'profile.settings'>
+ * // { profile: { name: string; email: string } }
+ * ```
+ */
+type DeepOmit<T, P extends string> = T extends object ? P extends '' ? T : DeepOmitBySegments<T, PathSegments<T, P>> : T;
+type DeepOmitBySegments<T, Segments extends string[]> = Segments extends [infer First extends string, ...infer Rest extends string[]] ? First extends keyof T ? Rest extends [] ? Omit<T, First> : { [K in keyof T]: K extends First ? DeepOmitBySegments<T[K], Rest> : T[K] } : T : T;
+/**
+ * Deep pick by path - keeps only properties at specified paths
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   profile: {
+ *     name: string
+ *     email: string
+ *     settings: {
+ *       theme: string
+ *       lang: string
+ *     }
+ *   }
+ * }
+ *
+ * DeepPick<User, 'profile.name' | 'profile.settings.theme'>
+ * // { profile: { name: string; settings: { theme: string } } }
+ * ```
+ */
+type DeepPick<T, P extends string> = T extends object ? P extends '' ? T : DeepPickBySegments<T, PathSegments<T, P>> : T;
+type DeepPickBySegments<T, Segments extends string[]> = Segments extends [infer First extends string, ...infer Rest extends string[]] ? First extends keyof T ? Rest extends [] ? Pick<T, First> : { [K in First]: DeepPickBySegments<T[K], Rest> } : Record<string, never> : T;
+/**
+ * Deep pick for union paths
+ */
+type DeepPickPaths<T, P extends string> = P extends P ? DeepPick<T, P> : never;
+/**
+ * Deep omit for union paths
+ */
+type DeepOmitPaths<T, P extends string> = P extends P ? DeepOmit<T, P> : never;
+//#endregion
 //#region src/deep/index.d.ts
 type BuiltIn = Date | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | RegExp;
 /**
@@ -231,317 +428,2525 @@ 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/guards/index.d.ts
+//#region src/ecosystem/prisma.d.ts
 /**
- * Check if type is an array
+ * Prisma ORM integration types
+ *
+ * These types help work with Prisma models and operations.
+ * Note: Prisma is an optional peer dependency.
+ */
+/**
+ * Prisma model type helper
  *
  * @example
  * ```ts
- * IsArray<string[]> // true
- * IsArray<string>   // false
+ * // Assuming you have a User model in Prisma
+ * type UserModel = PrismaModel<User>
  * ```
  */
-type IsArray<T> = T extends readonly unknown[] ? T extends readonly [...unknown[]] ? true : false : false;
+type PrismaModel<T> = T;
 /**
- * Check if type is a tuple
+ * Prisma create input type
  *
  * @example
  * ```ts
- * IsTuple<[string, number]> // true
- * IsTuple<string[]>         // false
+ * type CreateInput = PrismaCreateInput<User>
+ * // { name: string; email: string; age?: number }
  * ```
  */
-type IsTuple<T> = T extends readonly [unknown, ...unknown[]] ? T extends readonly unknown[] ? number extends T['length'] ? false : true : false : false;
+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] };
 /**
- * Check if two types are equal
+ * Prisma update input type
  *
  * @example
  * ```ts
- * IsEqual<string, string>   // true
- * IsEqual<string, number>   // false
+ * type UpdateInput = PrismaUpdateInput<User>
+ * // { name?: string; email?: string; age?: number }
  * ```
  */
-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 PrismaUpdateInput<T> = { [K in keyof T]?: T[K] | null };
 /**
- * Check if type is never
+ * Prisma where input type for unique lookup
+ *
+ * @example
+ * ```ts
+ * type UniqueWhere = PrismaUniqueWhere<User, 'id' | 'email'>
+ * // { id: string } | { email: string }
+ * ```
  */
-type IsNever<T> = [T] extends [never] ? true : false;
+type PrismaUniqueWhere<T, UniqueFields extends keyof T> = { [K in UniqueFields]: { [P in K]: T[P] } }[UniqueFields];
 /**
- * Check if type is unknown
+ * Prisma where input type
+ *
+ * @example
+ * ```ts
+ * type WhereInput = PrismaWhereInput<User>
+ * // { id?: string; name?: string; AND?: WhereInput[]; OR?: WhereInput[] }
+ * ```
  */
-type IsUnknown<T> = IsEqual<T, unknown> extends true ? IsAny<T> extends true ? false : true : false;
-//#endregion
-//#region src/infer/index.d.ts
+type PrismaWhereInput<T> = Partial<T> & {
+  AND?: PrismaWhereInput<T>[];
+  OR?: PrismaWhereInput<T>[];
+  NOT?: PrismaWhereInput<T>[];
+};
 /**
- * Get Promise value type (recursive unwrapping)
+ * Prisma order by input type
  *
  * @example
  * ```ts
- * Awaited<Promise<string>>        // string
- * Awaited<Promise<Promise<number>>> // number
+ * type OrderBy = PrismaOrderByInput<User>
+ * // { name?: 'asc' | 'desc'; createdAt?: 'asc' | 'desc' }
  * ```
  */
-type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
+type PrismaOrderByInput<T> = { [K in keyof T]?: 'asc' | 'desc' };
 /**
- * Get array element type
+ * Prisma select type
  *
  * @example
  * ```ts
- * ArrayElement<string[]>  // string
- * ArrayElement<(number | boolean)[]> // number | boolean
+ * type Select = PrismaSelect<User, 'name' | 'email'>
+ * // { name: true; email: true }
  * ```
  */
-type ArrayElement<T> = T extends readonly (infer E)[] ? E : never;
+type PrismaSelect<T, Keys extends keyof T = keyof T> = { [K in Keys]?: true };
 /**
- * Get object value type
+ * Prisma include type (for relations)
  *
  * @example
  * ```ts
- * ValueOf<{ a: string; b: number }> // string | number
+ * type Include = PrismaInclude<User, 'posts'>
+ * // { posts: true }
  * ```
  */
-type ValueOf<T> = T[keyof T];
+type PrismaInclude<T, Keys extends keyof T = keyof T> = { [K in Keys]?: true | {
+  select?: Partial<T>;
+} };
 /**
- * Get function type keys
+ * Extract scalar (non-relation) fields from a Prisma model
  *
  * @example
  * ```ts
- * interface Obj {
- *   name: string
- *   onClick: () => void
- *   onChange: (v: string) => void
- * }
- * FunctionKeys<Obj> // 'onClick' | 'onChange'
+ * type Scalars = PrismaScalarFields<User>
+ * // 'id' | 'name' | 'email' | 'createdAt'
  * ```
  */
-type FunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
+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];
 /**
- * Get non-function type keys
+ * Extract relation fields from a Prisma model
  *
  * @example
  * ```ts
- * interface Obj {
- *   name: string
- *   onClick: () => void
- * }
- * NonFunctionKeys<Obj> // 'name'
+ * type Relations = PrismaRelationFields<User>
+ * // 'posts' | 'comments'
  * ```
  */
-type NonFunctionKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? never : K }[keyof T];
+type PrismaRelationFields<T> = Exclude<keyof T, PrismaScalarFields<T>>;
 /**
- * Get function's first parameter type
+ * Prisma pagination args
  */
-type FirstParameter<T> = T extends ((first: infer F, ...rest: any[]) => any) ? F : never;
+interface PrismaPagination {
+  skip?: number;
+  take?: number;
+  cursor?: Record<string, unknown>;
+}
 /**
- * Extract function properties
+ * Prisma find many args
  */
-type FunctionOnly<T> = Pick<T, FunctionKeys<T>>;
+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>>;
+}
 /**
- * Extract non-function properties
+ * Prisma find first args
  */
-type DataOnly<T> = Pick<T, NonFunctionKeys<T>>;
+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/utils/path.d.ts
-type Primitive = string | number | boolean | null | undefined | symbol | bigint;
-type Join<K, P> = K extends string | number ? P extends string | number ? `${K}${'' extends P ? '' : '.'}${P}` : never : never;
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+//#region src/ecosystem/react.d.ts
 /**
- * Get all possible paths to nested properties
+ * React component props utilities
+ *
+ * These types help work with React component props.
+ * Note: React is an optional peer dependency.
+ */
+/**
+ * Extract props from a React component
  *
  * @example
- * ```ts
- * interface Obj {
- *   a: {
- *     b: string
- *     c: {
- *       d: number
- *     }
- *   }
- * }
+ * ```tsx
+ * import type { ComponentProps } from 'uni-types'
  *
- * type P = Paths<Obj>
- * // 'a' | 'a.b' | 'a.c' | 'a.c.d'
+ * type ButtonProps = ComponentProps<'button'>
+ * type InputProps = ComponentProps<'input'>
  * ```
  */
-type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends Primitive ? never : { [K in keyof T]: T[K] extends Primitive ? `${K & string}` : Join<K, Paths<T[K], Prev[D]>> }[keyof T];
+type ComponentProps<T> = T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : T extends ReactComponentType<infer P> ? P : never;
 /**
- * Get the value type at a given path
+ * Get props with ref included
  *
  * @example
- * ```ts
- * interface Obj {
- *   a: {
- *     b: string
- *   }
- * }
- *
- * type V = PathValue<Obj, 'a.b'> // string
+ * ```tsx
+ * type ButtonPropsWithRef = ComponentPropsWithRef<'button'>
  * ```
  */
-type PathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
+type ComponentPropsWithRef<T> = T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] & {
+  ref?: unknown;
+} : T extends ReactComponentType<infer P> ? P & {
+  ref?: unknown;
+} : never;
 /**
- * Split a path string into an array
+ * Add children to props
  *
  * @example
- * ```ts
- * SplitPath<'a.b.c'> // ['a', 'b', 'c']
+ * ```tsx
+ * type Props = PropsWithChildren<{ name: string }>
+ * // { name: string; children?: React.ReactNode }
  * ```
  */
-type SplitPath<S extends string, Acc extends string[] = []> = S extends `${infer H}.${infer T}` ? SplitPath<T, [...Acc, H]> : S extends `${infer H}` ? [...Acc, H] : Acc;
-//#endregion
-//#region src/utils/index.d.ts
+type PropsWithChildren<P = unknown> = P & {
+  children?: ReactNode;
+};
 /**
- * Merge two types (latter overrides former)
+ * Remove children from props
  *
  * @example
- * ```ts
- * Merge<{ a: string; b: number }, { b: boolean; c: string }>
- * // { a: string; b: boolean; c: string }
+ * ```tsx
+ * type Props = PropsWithoutChildren<{ name: string; children: ReactNode }>
+ * // { name: string }
  * ```
  */
-type Merge<T, U> = Omit<T, keyof U> & U;
+type PropsWithoutChildren<P> = Omit<P, 'children'>;
 /**
- * Non null/undefined
+ * Extract the prop types from a component
  *
  * @example
- * ```ts
- * NonNullable<string | null | undefined> // string
+ * ```tsx
+ * const MyComponent = (props: { name: string; age: number }) => null
+ * type Props = ExtractPropTypes<typeof MyComponent>
+ * // { name: string; age: number }
  * ```
  */
-type NonNullable<T> = T & {};
+type ExtractPropTypes<T> = T extends ReactComponentType<infer P> ? P : never;
 /**
- * Exclusive properties (only one can be selected)
+ * Get required props from a component
  *
  * @example
- * ```ts
- * type Result = Exclusive<{ type: 'a'; valueA: string } | { type: 'b'; valueB: number }, 'type'>
- * // Only type: 'a' or type: 'b' can be selected
+ * ```tsx
+ * interface Props {
+ *   name: string      // required
+ *   age?: number      // optional
+ *   onChange?: () => void
+ * }
+ *
+ * type Required = RequiredProps<Props>
+ * // 'name'
  * ```
  */
-type Exclusive<T, K extends keyof T> = T extends unknown ? Omit<T, K> & { [P in K]?: never } : never;
+type RequiredProps<P> = { [K in keyof P]-?: {} extends Pick<P, K> ? never : K }[keyof P];
 /**
- * Remove null and undefined from all properties
+ * Get optional props from a component
+ *
+ * @example
+ * ```tsx
+ * interface Props {
+ *   name: string      // required
+ *   age?: number      // optional
+ *   onChange?: () => void
+ * }
+ *
+ * type Optional = OptionalProps<Props>
+ * // 'age' | 'onChange'
+ * ```
  */
-type NoNullish<T> = { [K in keyof T]: NonNullable<T[K]> };
+type OptionalProps<P> = { [K in keyof P]-?: {} extends Pick<P, K> ? K : never }[keyof P];
 /**
- * Make all properties optional while preserving undefined/null values
+ * Props for forward ref components
+ *
+ * @example
+ * ```tsx
+ * type InputProps = ForwardRefProps<'input'>
+ * ```
  */
-type LoosePartial<T> = { [P in keyof T]?: T[P] };
+type ForwardRefProps<T extends keyof JSX.IntrinsicElements> = ComponentProps<T> & {
+  ref?: unknown;
+};
 /**
- * Literal types
+ * Merge props with default props
+ *
+ * @example
+ * ```tsx
+ * interface Props {
+ *   size?: 'sm' | 'md' | 'lg'
+ *   variant?: 'primary' | 'secondary'
+ * }
+ *
+ * type WithDefaults = MergeDefaultProps<Props, { size: 'md' }>
+ * // size becomes optional with default 'md'
+ * ```
  */
-type Literal = string | number | boolean | undefined | null | void | bigint;
+type MergeDefaultProps<P, D extends Partial<P>> = Omit<P, keyof D> & { [K in keyof D]?: P extends Record<K, infer V> ? V : D[K] };
 /**
- * Exact literal types
+ * Props with style
  */
-type LiteralString<T extends string> = T;
-type LiteralNumber<T extends number> = T;
-type LiteralBoolean<T extends boolean> = T;
+type PropsWithStyle<P = unknown> = P & {
+  style?: CSSProperties;
+};
 /**
- * Nullable type
+ * Props with className
  */
-type Nullable<T> = T | null;
+type PropsWithClassName<P = unknown> = P & {
+  className?: string;
+};
 /**
- * Optional type
+ * Props with style and className
  */
-type Optional<T> = T | undefined;
+type PropsWithStyleAndClassName<P = unknown> = P & {
+  style?: CSSProperties;
+  className?: string;
+};
 /**
- * Maybe type (nullable and optional)
+ * Event handler type
  */
-type Maybe<T> = T | null | undefined;
+type EventHandler<E = SyntheticEvent> = (event: E) => void;
 /**
- * Convert string to camelCase
+ * Change event handler
  */
-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;
+type ChangeEventHandler = (event: SyntheticEvent) => void;
 /**
- * Convert object keys to camelCase
+ * Mouse event handler
  */
-type CamelCaseKeys<T> = { [K in keyof T as CamelCase<string & K>]: T[K] };
+type MouseEventHandler = (event: SyntheticEvent) => void;
 /**
- * Convert string to snake_case
- * Handles consecutive uppercase letters correctly (e.g., XMLParser -> xml_parser)
+ * Keyboard event handler
  */
-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 KeyboardEventHandler = (event: SyntheticEvent) => void;
 /**
- * Convert object keys to snake_case
+ * Focus event handler
  */
-type SnakeCaseKeys<T> = { [K in keyof T as SnakeCase<string & K>]: T[K] };
+type FocusEventHandler = (event: SyntheticEvent) => void;
 /**
- * Require at least one property
+ * Form event handler
  */
-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];
+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/ecosystem/trpc.d.ts
 /**
- * Strict extract
+ * tRPC integration types
+ *
+ * These types help work with tRPC routers and procedures.
+ * Note: tRPC is an optional peer dependency.
  */
-type StrictExtract<T, U extends keyof any> = T extends Record<U, any> ? T : never;
 /**
- * Strict exclude
+ * tRPC router shape
+ *
+ * @example
+ * ```ts
+ * 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 StrictExclude<T, U extends T> = T extends U ? never : T;
+type TRPCRouterShape<T> = T extends {
+  _def: {
+    router: infer R;
+  };
+} ? R : T;
 /**
- * Convert union type to intersection type
+ * Extract input type from tRPC procedure
+ *
+ * @example
+ * ```ts
+ * const procedure = t.procedure.input(z.object({ name: z.string() }))
+ *
+ * type Input = TRPCProcedureInput<typeof procedure>
+ * // { name: string }
+ * ```
  */
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type TRPCProcedureInput<T> = T extends {
+  _def: {
+    inputs: infer I;
+  };
+} ? I extends [infer First, ...unknown[]] ? First : I : T extends {
+  _def: {
+    input: infer I;
+  };
+} ? I : never;
 /**
- * Convert union type to tuple
+ * Extract output type from tRPC procedure
+ *
+ * @example
+ * ```ts
+ * const procedure = t.procedure.output(z.object({ name: z.string() }))
+ *
+ * type Output = TRPCProcedureOutput<typeof procedure>
+ * // { name: string }
+ * ```
  */
-type UnionToTuple<T> = UnionToIntersection<T extends unknown ? (t: T) => T : never> extends ((_: any) => infer W) ? [...UnionToTuple<Exclude<T, W>>, W] : [];
+type TRPCProcedureOutput<T> = T extends {
+  _def: {
+    output: infer O;
+  };
+} ? O : never;
 /**
- * Get all required keys of a type
+ * tRPC procedure type
+ */
+type TRPCProcedureType = 'query' | 'mutation' | 'subscription';
+/**
+ * Extract procedure type from tRPC procedure
+ */
+type TRPCExtractProcedureType<T> = T extends {
+  _def: {
+    type: infer P;
+  };
+} ? P extends TRPCProcedureType ? P : never : never;
+/**
+ * tRPC error shape
  *
  * @example
  * ```ts
- * interface User {
- *   name: string
- *   age?: number
+ * type Error = TRPCErrorShape<{ message: string }>
+ * ```
+ */
+interface TRPCErrorShape<T = unknown> {
+  message: string;
+  code: string;
+  data?: T;
+}
+/**
+ * tRPC context type
+ *
+ * @example
+ * ```ts
+ * interface Context {
+ *   user?: { id: string }
+ *   session: Session
  * }
- * RequiredKeys<User> // 'name'
+ *
+ * type AppContext = TRPCContext<Context>
  * ```
  */
-type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
+type TRPCContext<T> = T;
 /**
- * Get all optional keys of a type
+ * tRPC middleware type
  *
  * @example
  * ```ts
- * interface User {
+ * type Middleware = TRPCMiddleware<{ user: User }>
+ * ```
+ */
+type TRPCMiddleware<T = unknown> = (opts: {
+  ctx: T;
+  next: () => Promise<void>;
+}) => Promise<void>;
+/**
+ * tRPC router record
+ */
+type TRPCRouterRecord = Record<string, unknown>;
+/**
+ * Merge multiple tRPC routers
+ */
+type TRPCMergeRouters<T extends TRPCRouterRecord[]> = T extends [infer First extends TRPCRouterRecord, ...infer Rest extends TRPCRouterRecord[]] ? Rest extends [] ? First : First & TRPCMergeRouters<Rest> : Record<string, never>;
+/**
+ * tRPC procedure builder
+ */
+interface TRPCProcedureBuilder<T = unknown> {
+  _def: {
+    input: T;
+    output: unknown;
+    type: TRPCProcedureType;
+  };
+}
+/**
+ * Get all query procedures from router
+ */
+type TRPCQueries<T> = T extends object ? { [K in keyof T]: T[K] extends {
+  _def: {
+    type: 'query';
+  };
+} ? K : never }[keyof T] : never;
+/**
+ * Get all mutation procedures from router
+ */
+type TRPCMutations<T> = T extends object ? { [K in keyof T]: T[K] extends {
+  _def: {
+    type: 'mutation';
+  };
+} ? K : never }[keyof T] : never;
+/**
+ * Get all subscription procedures from router
+ */
+type TRPCSubscriptions<T> = T extends object ? { [K in keyof T]: T[K] extends {
+  _def: {
+    type: 'subscription';
+  };
+} ? K : never }[keyof T] : never;
+/**
+ * tRPC client type
+ */
+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>;
+}
+/**
+ * tRPC caller type
+ */
+type TRPSCaller<T, Context = unknown> = (ctx: Context) => TRPCCallerRouter<T>;
+/**
+ * tRPC caller router type
+ */
+type TRPCCallerRouter<T> = { [K in keyof T]: TRPCProcedureCaller<T[K]> };
+/**
+ * tRPC procedure caller type
+ */
+type TRPCProcedureCaller<T> = (input: TRPCProcedureInput<T>) => Promise<TRPCProcedureOutput<T>>;
+//#endregion
+//#region src/ecosystem/vue.d.ts
+/**
+ * Vue component props utilities
+ *
+ * These types help work with Vue component props.
+ * Note: Vue is an optional peer dependency.
+ */
+/**
+ * Vue prop type definition
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const props = defineProps<{
  *   name: string
  *   age?: number
+ * }>()
+ * </script>
+ * ```
+ */
+interface VuePropType<T> {
+  type: VuePropConstructor<T>;
+  required?: boolean;
+  default?: T | (() => T);
+}
+/**
+ * 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 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
- *   readonly age: number
+ * const props = {
+ *   name: String,
+ *   age: { type: Number, required: false }
  * }
- * WritableKeys<User> // 'name'
+ *
+ * type Normalized = NormalizeVueProps<typeof props>
+ * // { name: string; age?: number }
  * ```
  */
-type WritableKeys<T> = { [K in keyof T]: IfEquals<Readonly<Pick<T, K>>, Pick<T, K>, K, never> }[keyof T];
+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 };
 /**
- * Get all readonly keys of a type
+ * 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 User {
- *   name: string
- *   readonly age: number
+ * interface Props {
+ *   modelValue: string
+ *   'onUpdate:modelValue'?: (value: string) => void
  * }
- * ReadonlyKeys<User> // 'age'
+ *
+ * type Model = VueModelProps<'modelValue', string>
  * ```
  */
-type ReadonlyKeys<T> = { [K in keyof T]: IfEquals<Readonly<Pick<T, K>>, Pick<T, K>, never, K> }[keyof T];
-type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
+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'
+ * ```
+ */
+type WritableKeys<T> = { [K in keyof T]: IfEquals<Readonly<Pick<T, K>>, Pick<T, K>, K, never> }[keyof T];
+/**
+ * Get all readonly keys of a type
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
+ *   readonly age: number
+ * }
+ * ReadonlyKeys<User> // 'age'
+ * ```
+ */
+type ReadonlyKeys<T> = { [K in keyof T]: IfEquals<Readonly<Pick<T, K>>, Pick<T, K>, never, K> }[keyof T];
+type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
+//#endregion
+//#region src/keys/index.d.ts
+/**
+ * Get all keys as literal union
+ *
+ * @example
+ * ```ts
+ * Keys<{ a: string; b: number }> // 'a' | 'b'
+ * ```
+ */
+type Keys<T> = keyof T;
+/**
+ * Rename object keys based on a mapping
+ *
+ * @example
+ * ```ts
+ * RenameKeys<{ oldName: string }, { oldName: 'newName' }>
+ * // { newName: string }
+ * ```
+ */
+type RenameKeys<T, M extends Record<string, string>> = { [K in keyof T as K extends keyof M ? M[K] : K]: T[K] };
+/**
+ * Prefix all keys with a string
+ *
+ * @example
+ * ```ts
+ * PrefixKeys<{ a: string; b: number }, 'data'>
+ * // { dataA: string; dataB: number }
+ * ```
+ */
+type PrefixKeys<T, P extends string> = { [K in keyof T as `${P}${Capitalize<K & string>}`]: T[K] };
+/**
+ * Suffix all keys with a string
+ *
+ * @example
+ * ```ts
+ * SuffixKeys<{ a: string; b: number }, 'Data'>
+ * // { aData: string; bData: number }
+ * ```
+ */
+type SuffixKeys<T, S extends string> = { [K in keyof T as `${K & string}${S}`]: T[K] };
+/**
+ * Convert keys to PascalCase
+ *
+ * @example
+ * ```ts
+ * PascalCaseKeys<{ helloWorld: string }>
+ * // { HelloWorld: string }
+ * ```
+ */
+type PascalCaseKeys<T> = { [K in keyof T as Capitalize<CamelCase<K & string>>]: T[K] };
+/**
+ * Get keys by value type
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   name: string
+ *   age: number
+ *   email: string
+ * }
+ *
+ * KeysByValueType<User, string> // 'name' | 'email'
+ * ```
+ */
+type KeysByValueType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+/**
+ * Get keys that match a pattern
+ *
+ * @example
+ * ```ts
+ * interface User {
+ *   userName: string
+ *   userId: number
+ *   userEmail: string
+ *   age: number
+ * }
+ *
+ * FilterKeys<User, `user${string}`> // 'userName' | 'userId' | 'userEmail'
+ * ```
+ */
+type FilterKeys<T, P extends string> = keyof T extends infer K ? K extends P ? K : never : never;
+//#endregion
+//#region src/numeric/index.d.ts
+/**
+ * Numeric type operations for compile-time arithmetic
+ */
+type NumberToArray<N extends number, Acc extends 0[] = []> = Acc['length'] extends N ? Acc : NumberToArray<N, [...Acc, 0]>;
+/**
+ * Increment number type
+ *
+ * @example
+ * ```ts
+ * Inc<5>   // 6
+ * Inc<0>   // 1
+ * ```
+ */
+type Inc<N extends number> = [...NumberToArray<N>, 0]['length'];
+/**
+ * Decrement number type
+ *
+ * @example
+ * ```ts
+ * Dec<5>   // 4
+ * Dec<1>   // 0
+ * Dec<0>   // 0 (clamped)
+ * ```
+ */
+type Dec<N extends number> = N extends 0 ? 0 : NumberToArray<N> extends [0, ...infer Rest] ? Rest['length'] : 0;
+/**
+ * Add two number types
+ *
+ * @example
+ * ```ts
+ * Add<3, 4>   // 7
+ * Add<0, 5>   // 5
+ * ```
+ */
+type Add<A extends number, B extends number> = [...NumberToArray<A>, ...NumberToArray<B>]['length'];
+/**
+ * Subtract two number types
+ *
+ * @example
+ * ```ts
+ * Subtract<10, 3>  // 7
+ * Subtract<5, 10>  // 0 (clamped)
+ * ```
+ */
+type Subtract<A extends number, B extends number> = NumberToArray<B> extends [...number[], ...NumberToArray<A>] ? 0 : NumberToArray<A> extends [...NumberToArray<B>, ...infer Rest] ? Rest['length'] : 0;
+/**
+ * Range of numbers from start to end (inclusive)
+ * Note: Limited to small ranges due to TypeScript recursion limits
+ *
+ * @example
+ * ```ts
+ * Range<1, 5>  // 1 | 2 | 3 | 4 | 5
+ * Range<0, 3>  // 0 | 1 | 2 | 3
+ * ```
+ */
+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
+ *
+ * @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
+ * type Complex = Deferred<{ a: string } & { b: number }>
+ * ```
+ */
+type Deferred<T> = T extends infer U ? U : never;
+/**
+ * Thunk type - zero-argument function returning a type
+ *
+ * @example
+ * ```ts
+ * type StringThunk = Thunk<string>
+ * // () => string
+ * ```
+ */
+type Thunk<T> = () => T;
+/**
+ * Lazy property access
+ *
+ * @example
+ * ```ts
+ * type Props = { a: string; b: number; c: boolean }
+ * type LazyA = LazyKey<Props, 'a'>  // () => Props['a']
+ * ```
+ */
+type LazyKey<T, K extends keyof T> = () => T[K];
+/**
+ * Lazy conditional - defers conditional evaluation
+ *
+ * @example
+ * ```ts
+ * type Cond = LazyConditional<true, string, number>
+ * // () => string
+ * ```
+ */
+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/perf/optimize.d.ts
+/**
+ * Type optimization utilities
+ *
+ * These types help simplify and optimize complex types for better compilation.
+ */
+/**
+ * Simplify complex types - flatten intersections
+ *
+ * @example
+ * ```ts
+ * type Complex = { a: string } & { b: number }
+ * type Simple = Simplify<Complex>
+ * // { a: string; b: number }
+ * ```
+ */
+type Simplify<T> = { [K in keyof T]: T[K] } & unknown;
+/**
+ * Deep simplify - recursively flatten types
+ *
+ * @example
+ * ```ts
+ * 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
+ *
+ * @example
+ * ```ts
+ * type Flat = FlattenType<{ a: string } & { b: number } & { c: boolean }>
+ * // { a: string; b: number; c: boolean }
+ * ```
+ */
+type FlattenType<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
+/**
+ * Reduce intersection - simplify intersection types
+ *
+ * @example
+ * ```ts
+ * 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
+ *
+ * @example
+ * ```ts
+ * type Reduced = ReduceUnion<string | number | string>
+ * // string | number
+ * ```
+ */
+type ReduceUnion<T> = T extends infer U ? U : never;
+/**
+ * Compact type - remove never and undefined from objects
+ *
+ * @example
+ * ```ts
+ * type Compacted = Compact<{ a: string; b: never; c?: undefined }>
+ * // { a: string }
+ * ```
+ */
+type Compact<T> = { [K in keyof T as T[K] extends never ? never : undefined extends T[K] ? never : K]: T[K] };
+/**
+ * Strip never from object
+ *
+ * @example
+ * ```ts
+ * type Stripped = StripNever<{ a: string; b: never; c: number }>
+ * // { a: string; c: number }
+ * ```
+ */
+type StripNever<T> = { [K in keyof T as T[K] extends never ? never : K]: T[K] };
+/**
+ * Strip undefined from object
+ *
+ * @example
+ * ```ts
+ * type Stripped = StripUndefined<{ a: string; b?: undefined; c: number }>
+ * // { a: string; c: number }
+ * ```
+ */
+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
+/**
+ * Record and object manipulation types
+ */
+/**
+ * Deep nullable - make all properties nullable
+ *
+ * @example
+ * ```ts
+ * DeepNullable<{ a: { b: string } }>
+ * // { a: { b: string | null } }
+ * ```
+ */
+type DeepNullable<T> = T extends ((...args: any[]) => any) ? T : T extends Map<infer K, infer V> ? Map<DeepNullable<K>, DeepNullable<V>> : T extends Set<infer V> ? Set<DeepNullable<V>> : T extends readonly (infer E)[] ? DeepNullable<E>[] : T extends object ? { [K in keyof T]: DeepNullable<T[K]> | null } : T | null;
+/**
+ * Deep optional - make all properties optional
+ *
+ * @example
+ * ```ts
+ * DeepOptional<{ a: { b: string } }>
+ * // { a?: { b?: string } }
+ * ```
+ */
+type DeepOptional<T> = T extends ((...args: any[]) => any) ? T : T extends Map<infer K, infer V> ? Map<DeepOptional<K>, DeepOptional<V>> : T extends Set<infer V> ? Set<DeepOptional<V>> : T extends readonly (infer E)[] ? DeepOptional<E>[] : T extends object ? { [K in keyof T]?: DeepOptional<T[K]> } : T;
+/**
+ * Immutable object - deep readonly alternative
+ *
+ * @example
+ * ```ts
+ * Immutable<{ a: { b: string[] } }>
+ * // { readonly a: { readonly b: readonly string[] } }
+ * ```
+ */
+type Immutable<T> = T extends ((...args: any[]) => any) ? T : T extends Map<infer K, infer V> ? ReadonlyMap<Immutable<K>, Immutable<V>> : T extends Set<infer V> ? ReadonlySet<Immutable<V>> : T extends readonly (infer E)[] ? readonly Immutable<E>[] : T extends object ? { readonly [K in keyof T]: Immutable<T[K]> } : T;
+/**
+ * Mutable object - deep mutable alternative
+ *
+ * @example
+ * ```ts
+ * Mutable<{ readonly a: { readonly b: readonly string[] } }>
+ * // { a: { b: string[] } }
+ * ```
+ */
+type Mutable<T> = T extends ((...args: any[]) => any) ? T : T extends Map<infer K, infer V> ? Map<Mutable<K>, Mutable<V>> : T extends Set<infer V> ? Set<Mutable<V>> : T extends readonly (infer E)[] ? Mutable<E>[] : T extends object ? { -readonly [K in keyof T]: Mutable<T[K]> } : T;
+/**
+ * Deep non-nullable - remove null and undefined from all properties
+ *
+ * @example
+ * ```ts
+ * DeepNonNullable<{ a: string | null; b: number | undefined }>
+ * // { a: string; b: number }
+ * ```
+ */
+type DeepNonNullable<T> = T extends ((...args: any[]) => any) ? T : T extends Map<infer K, infer V> ? Map<DeepNonNullable<K>, DeepNonNullable<V>> : T extends Set<infer V> ? Set<DeepNonNullable<V>> : T extends readonly (infer E)[] ? DeepNonNullable<E>[] : T extends object ? { [K in keyof T]: DeepNonNullable<NonNullable<T[K]>> } : NonNullable<T>;
+/**
+ * Exact type - ensure object has exactly these keys
+ *
+ * @example
+ * ```ts
+ * Exact<{ a: string }, { a: string }>       // { a: string }
+ * Exact<{ a: string }, { a: string, b: number }>  // never
+ * ```
+ */
+type Exact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? T : never : never;
+/**
+ * Make all properties non-optional
+ *
+ * @example
+ * ```ts
+ * Required<{ a?: string; b?: number }>
+ * // { a: string; b: number }
+ * ```
+ */
+type Required$1<T> = { [K in keyof T]-?: T[K] };
+/**
+ * Deep required with null/undefined handling
+ *
+ * @example
+ * ```ts
+ * DeepRequired<{ a?: { b?: string } }>
+ * // { a: { b: string } }
+ * ```
+ */
+type DeepRequiredProperties<T> = T extends ((...args: any[]) => any) ? T : T extends Map<infer K, infer V> ? Map<DeepRequiredProperties<K>, DeepRequiredProperties<V>> : T extends Set<infer V> ? Set<DeepRequiredProperties<V>> : T extends readonly (infer E)[] ? DeepRequiredProperties<E>[] : T extends object ? { [K in keyof T]-?: DeepRequiredProperties<T[K]> } : T;
+/**
+ * Object with at least the specified keys
+ *
+ * @example
+ * ```ts
+ * HasKeys<{ a: string; b: number }, 'a'>
+ * // { a: string; b: number }
+ * HasKeys<{ a: string }, 'b'>
+ * // never
+ * ```
+ */
+type HasKeys<T, K extends keyof any> = K extends keyof T ? T : never;
+/**
+ * Object with exactly the specified keys
+ *
+ * @example
+ * ```ts
+ * HasExactKeys<{ a: string }, 'a'>
+ * // true
+ * HasExactKeys<{ a: string; b: number }, 'a'>
+ * // false
+ * ```
+ */
+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
+ */
+/**
+ * Replace all occurrences of a substring
+ *
+ * @example
+ * ```ts
+ * ReplaceAll<'hello world world', 'world', 'there'>  // 'hello there there'
+ * ReplaceAll<'aaa', 'a', 'b'>  // 'bbb'
+ * ```
+ */
+type ReplaceAll<S extends string, From extends string, To extends string> = From extends '' ? S : S extends `${infer Before}${From}${infer After}` ? `${Before}${To}${ReplaceAll<After, From, To>}` : S;
+/**
+ * Replace first occurrence of a substring
+ *
+ * @example
+ * ```ts
+ * Replace<'hello world world', 'world', 'there'>  // 'hello there world'
+ * ```
+ */
+type Replace<S extends string, From extends string, To extends string> = From extends '' ? S : S extends `${infer Before}${From}${infer After}` ? `${Before}${To}${After}` : S;
+/**
+ * Trim whitespace from both ends
+ *
+ * @example
+ * ```ts
+ * Trim<'  hello  '>  // 'hello'
+ * Trim<'\n\ttext\n'>  // 'text'
+ * ```
+ */
+type Trim<S extends string> = TrimLeft<TrimRight<S>>;
+/**
+ * Trim whitespace from left
+ *
+ * @example
+ * ```ts
+ * TrimLeft<'  hello'>  // 'hello'
+ * ```
+ */
+type TrimLeft<S extends string> = S extends ` ${infer Rest}` ? TrimLeft<Rest> : S extends `\n${infer Rest}` ? TrimLeft<Rest> : S extends `\t${infer Rest}` ? TrimLeft<Rest> : S extends `\r${infer Rest}` ? TrimLeft<Rest> : S;
+/**
+ * Trim whitespace from right
+ *
+ * @example
+ * ```ts
+ * TrimRight<'hello  '>  // 'hello'
+ * ```
+ */
+type TrimRight<S extends string> = S extends `${infer Rest} ` ? TrimRight<Rest> : S extends `${infer Rest}\n` ? TrimRight<Rest> : S extends `${infer Rest}\t` ? TrimRight<Rest> : S extends `${infer Rest}\r` ? TrimRight<Rest> : S;
+/**
+ * Convert string to array of characters
+ *
+ * @example
+ * ```ts
+ * StringToArray<'abc'>  // ['a', 'b', 'c']
+ * ```
+ */
+type StringToArray<S extends string, Acc extends string[] = []> = S extends `${infer First}${infer Rest}` ? StringToArray<Rest, [...Acc, First]> : Acc;
+/**
+ * Capitalize all words in a string
+ *
+ * @example
+ * ```ts
+ * CapitalizeAll<'hello world'>  // 'Hello World'
+ * ```
+ */
+type CapitalizeAll<S extends string> = S extends `${infer First} ${infer Rest}` ? `${Capitalize<First>} ${CapitalizeAll<Rest>}` : S extends `${infer First}` ? Capitalize<First> : S;
+/**
+ * Uncapitalize all words in a string
+ *
+ * @example
+ * ```ts
+ * UncapitalizeAll<'Hello World'>  // 'hello world'
+ * ```
+ */
+type UncapitalizeAll<S extends string> = S extends `${infer First} ${infer Rest}` ? `${Uncapitalize<First>} ${UncapitalizeAll<Rest>}` : S extends `${infer First}` ? Uncapitalize<First> : S;
+/**
+ * Check if string starts with a prefix
+ *
+ * @example
+ * ```ts
+ * StartsWith<'hello world', 'hello'>  // true
+ * StartsWith<'hello world', 'world'>  // false
+ * ```
+ */
+type StartsWith<S extends string, P extends string> = S extends `${P}${any}` ? true : false;
+/**
+ * Check if string ends with a suffix
+ *
+ * @example
+ * ```ts
+ * EndsWith<'hello world', 'world'>  // true
+ * EndsWith<'hello world', 'hello'>  // false
+ * ```
+ */
+type EndsWith<S extends string, P extends string> = S extends `${any}${P}` ? true : false;
+/**
+ * Get string length at type level
+ *
+ * @example
+ * ```ts
+ * StringLength<'hello'>  // 5
+ * ```
+ */
+type StringLength<S extends string, Acc extends 0[] = []> = S extends `${string}${infer Rest}` ? StringLength<Rest, [...Acc, 0]> : Acc['length'];
+/**
+ * Repeat a string N times
+ *
+ * @example
+ * ```ts
+ * Repeat<'ab', 3>  // 'ababab'
+ * ```
+ */
+type Repeat<S extends string, N extends number, Acc extends string = '', Count extends 0[] = []> = Count['length'] extends N ? Acc : Repeat<S, N, `${Acc}${S}`, [...Count, 0]>;
+/**
+ * Pad string on the left
+ *
+ * @example
+ * ```ts
+ * PadStart<'5', 3, '0'>  // '005'
+ * ```
+ */
+type PadStart<S extends string, N extends number, P extends string = ' '> = StringLength<S> extends N ? S : N extends number ? `${P}${PadStart<S, Decrement<N>, P>}` : S;
+/**
+ * Pad string on the right
+ *
+ * @example
+ * ```ts
+ * PadEnd<'5', 3, '0'>  // '500'
+ * ```
+ */
+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 { ArrayElement, AtLeastOne, Awaited, CamelCase, CamelCaseKeys, DataOnly, DeepMutable, DeepPartial, DeepReadonly, DeepRequired, Exclusive, FirstParameter, Flatten, FunctionKeys, FunctionOnly, Head, Init, IsAny, IsArray, IsEmptyTuple, IsEqual, IsNever, IsTuple, IsUnknown, Last, Literal, LiteralBoolean, LiteralNumber, LiteralString, LoosePartial, Maybe, Merge, NoNullish, NonFunctionKeys, NonNullable, Nullable, OmitPartial, OmitRequired, Optional, OptionalKeys, PathValue, Paths, PickPartial, PickRequired, ReadonlyKeys, RequiredKeys, Reverse, SnakeCase, SnakeCaseKeys, SplitPath, StrictExclude, StrictExtract, Tail, TupleLength, UnionToIntersection, UnionToTuple, 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 };