uni-types 1.0.0 → 1.1.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,6 +428,123 @@ 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
+/**
+ * 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<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
@@ -345,54 +659,6 @@ type FunctionOnly<T> = Pick<T, FunctionKeys<T>>;
  */
 type DataOnly<T> = Pick<T, NonFunctionKeys<T>>;
 //#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];
-/**
- * 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 ? never : { [K in keyof T]: T[K] extends Primitive ? `${K & string}` : Join<K, Paths<T[K], Prev[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/utils/index.d.ts
 /**
  * Merge two types (latter overrides former)
@@ -412,7 +678,7 @@ type Merge<T, U> = Omit<T, keyof U> & U;
  * NonNullable<string | null | undefined> // string
  * ```
  */
-type NonNullable<T> = T & {};
+type NonNullable$1<T> = T & {};
 /**
  * Exclusive properties (only one can be selected)
  *
@@ -426,7 +692,7 @@ type Exclusive<T, K extends keyof T> = T extends unknown ? Omit<T, K> & { [P in
 /**
  * Remove null and undefined from all properties
  */
-type NoNullish<T> = { [K in keyof T]: NonNullable<T[K]> };
+type NoNullish<T> = { [K in keyof T]: NonNullable$1<T[K]> };
 /**
  * Make all properties optional while preserving undefined/null values
  */
@@ -544,4 +810,511 @@ type WritableKeys<T> = { [K in keyof T]: IfEquals<Readonly<Pick<T, K>>, Pick<T,
 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
-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 };
+//#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/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/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 { 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 };