@bgskinner2/ts-utils 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,2546 @@
+import * as react from 'react';
+import { ElementType, ComponentPropsWithoutRef, ReactElement, MouseEvent, ReactNode, ComponentType, ForwardRefExoticComponent, ReactPortal, Ref, RefObject } from 'react';
+
+/**  @see {@link TypeDocs.TStaticMethods}  */
+type TStaticMethods<T> = {
+    [K in keyof T as T[K] extends (...args: any) => any ? K : never]: T[K];
+};
+
+type TArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift' | number;
+type TArrayItems<T extends Array<unknown>> = T extends Array<infer TItems> ? TItems : never;
+type TFixedLengthArray<T extends unknown[]> = Pick<T, Exclude<keyof T, TArrayLengthMutationKeys>> & {
+    [Symbol.iterator]: () => IterableIterator<TArrayItems<T>>;
+} & {
+    length: number;
+};
+type TRGB = readonly [r: number, g: number, b: number];
+type TCssRGB = `rgb(${number}, ${number}, ${number})`;
+
+type TWords<S extends string, Acc extends string[] = []> = S extends `${infer First}${infer Rest}` ? First extends '-' | '_' | ' ' ? TWords<Rest, Acc> : Rest extends `${infer NextChar}${infer Remaining}` ? NextChar extends '-' | '_' | ' ' ? TWords<Remaining, [...Acc, First]> : TWords<`${NextChar}${Remaining}`, Acc extends [] ? [First] : [...Acc, First]> : [...Acc, First] : Acc;
+type TDelimiterCaseOptions = {
+    /**
+     * Whether to preserve consecutive uppercase letters.
+     * @default true
+     */
+    preserveConsecutiveUppercase?: boolean;
+};
+type TDefaultDelimiterCaseOptions = {
+    preserveConsecutiveUppercase: true;
+};
+type TMergeDelimiterCaseOptions<Options extends TDelimiterCaseOptions> = {
+    preserveConsecutiveUppercase: Options['preserveConsecutiveUppercase'] extends boolean ? Options['preserveConsecutiveUppercase'] : TDefaultDelimiterCaseOptions['preserveConsecutiveUppercase'];
+};
+
+/**
+ * Join an array of words with underscores (_), respecting preserveConsecutiveUppercase
+ */
+type SnakeCaseFromArray<WordsArr extends string[], Options extends {
+    preserveConsecutiveUppercase: boolean;
+}, OutputString extends string = ''> = WordsArr extends [
+    infer FirstWord extends string,
+    ...infer Rest extends string[]
+] ? Rest['length'] extends 0 ? Options['preserveConsecutiveUppercase'] extends true ? FirstWord : Lowercase<FirstWord> : Options['preserveConsecutiveUppercase'] extends true ? `${FirstWord}_${SnakeCaseFromArray<Rest, Options>}` : `${Lowercase<FirstWord>}_${SnakeCaseFromArray<Rest, Options>}` : OutputString;
+/**
+ * Convert a string literal to snake_case
+ */
+type TSnakeCase<Type, Options extends TDelimiterCaseOptions = object> = Type extends string ? string extends Type ? Type : SnakeCaseFromArray<TWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, TMergeDelimiterCaseOptions<Options>> : Type;
+
+type KebabCaseFromArray<WordsArr extends string[], Options extends {
+    preserveConsecutiveUppercase: boolean;
+}, OutputString extends string = ''> = WordsArr extends [
+    infer FirstWord extends string,
+    ...infer Rest extends string[]
+] ? Rest['length'] extends 0 ? Options['preserveConsecutiveUppercase'] extends true ? FirstWord : Lowercase<FirstWord> : Options['preserveConsecutiveUppercase'] extends true ? `${FirstWord}-${KebabCaseFromArray<Rest, Options>}` : `${Lowercase<FirstWord>}-${KebabCaseFromArray<Rest, Options>}` : OutputString;
+type TKebabCase<Type, Options extends TDelimiterCaseOptions = object> = Type extends string ? string extends Type ? Type : KebabCaseFromArray<TWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, TMergeDelimiterCaseOptions<Options>> : Type;
+
+type CamelCaseFromArray<WordsArr extends string[], Options extends {
+    preserveConsecutiveUppercase: boolean;
+}, OutputString extends string = ''> = WordsArr extends [
+    infer FirstWord extends string,
+    ...infer Rest extends string[]
+] ? Options['preserveConsecutiveUppercase'] extends true ? `${Capitalize<FirstWord>}${CamelCaseFromArray<Rest, Options>}` : `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<Rest, Options>}` : OutputString;
+type TCamelCase<Type, Options extends TDelimiterCaseOptions = object> = Type extends string ? string extends Type ? Type : Uncapitalize<CamelCaseFromArray<TWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, TMergeDelimiterCaseOptions<Options>>> : Type;
+
+declare const LOG_TYPES: readonly ["log", "warn", "error", "info", "debug", "table"];
+declare const REGEX_CONSTANTS: {
+    readonly isoRegex: RegExp;
+    readonly camelCase: RegExp;
+    readonly kebabCase: RegExp;
+    readonly snakeCase: RegExp;
+    readonly hexString: RegExp;
+    readonly hexColor: RegExp;
+    readonly letterSeparator: RegExp;
+    readonly camelCaseBoundary: RegExp;
+    readonly kebabCaseBoundary: RegExp;
+    readonly whitespace: RegExp;
+    readonly wordBoundarySplitter: RegExp;
+    readonly USPhoneNumber: RegExp;
+    readonly EUPhoneNumber: RegExp;
+    readonly genericPhoneNumber: RegExp;
+    readonly genericEmail: RegExp;
+    readonly emailRegex: RegExp;
+    readonly imageSrcRegex: RegExp;
+    readonly singleAlphabetChar: RegExp;
+    readonly htmlDetection: RegExp;
+    readonly stackTracePrefix: RegExp;
+};
+declare const ANSI_COLOR_CODES: {
+    readonly reset: "\u001B[0m";
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly bold: "\u001B[1m";
+    readonly underline: "\u001B[4m";
+};
+
+declare const VALID_DOM_PROPS: {
+    abbr: true;
+    accept: true;
+    acceptCharset: true;
+    accessKey: true;
+    action: true;
+    allow: true;
+    allowFullScreen: true;
+    allowPaymentRequest: true;
+    alt: true;
+    async: true;
+    autoComplete: true;
+    autoFocus: true;
+    autoPlay: true;
+    capture: true;
+    cellPadding: true;
+    cellSpacing: true;
+    challenge: true;
+    charSet: true;
+    checked: true;
+    cite: true;
+    classID: true;
+    className: true;
+    cols: true;
+    colSpan: true;
+    content: true;
+    contentEditable: true;
+    contextMenu: true;
+    controls: true;
+    controlsList: true;
+    coords: true;
+    crossOrigin: true;
+    data: true;
+    dateTime: true;
+    decoding: true;
+    default: true;
+    defer: true;
+    dir: true;
+    disabled: true;
+    disablePictureInPicture: true;
+    disableRemotePlayback: true;
+    download: true;
+    draggable: true;
+    encType: true;
+    enterKeyHint: true;
+    form: true;
+    formAction: true;
+    formEncType: true;
+    formMethod: true;
+    formNoValidate: true;
+    formTarget: true;
+    frameBorder: true;
+    headers: true;
+    height: true;
+    hidden: true;
+    high: true;
+    href: true;
+    hrefLang: true;
+    htmlFor: true;
+    httpEquiv: true;
+    id: true;
+    inputMode: true;
+    integrity: true;
+    is: true;
+    keyParams: true;
+    keyType: true;
+    kind: true;
+    label: true;
+    lang: true;
+    list: true;
+    loading: true;
+    loop: true;
+    low: true;
+    marginHeight: true;
+    marginWidth: true;
+    max: true;
+    maxLength: true;
+    media: true;
+    mediaGroup: true;
+    method: true;
+    min: true;
+    minLength: true;
+    multiple: true;
+    muted: true;
+    name: true;
+    nonce: true;
+    noValidate: true;
+    open: true;
+    optimum: true;
+    pattern: true;
+    placeholder: true;
+    playsInline: true;
+    poster: true;
+    preload: true;
+    profile: true;
+    radioGroup: true;
+    readOnly: true;
+    referrerPolicy: true;
+    rel: true;
+    required: true;
+    reversed: true;
+    role: true;
+    rows: true;
+    rowSpan: true;
+    sandbox: true;
+    scope: true;
+    scoped: true;
+    scrolling: true;
+    seamless: true;
+    selected: true;
+    shape: true;
+    size: true;
+    sizes: true;
+    slot: true;
+    span: true;
+    spellCheck: true;
+    src: true;
+    srcDoc: true;
+    srcLang: true;
+    srcSet: true;
+    start: true;
+    step: true;
+    style: true;
+    summary: true;
+    tabIndex: true;
+    target: true;
+    title: true;
+    translate: true;
+    type: true;
+    useMap: true;
+    value: true;
+    width: true;
+    wmode: true;
+    wrap: true;
+    alignmentBaseline: true;
+    baselineShift: true;
+    clip: true;
+    clipPath: true;
+    clipRule: true;
+    color: true;
+    colorInterpolation: true;
+    colorInterpolationFilters: true;
+    colorProfile: true;
+    colorRendering: true;
+    cursor: true;
+    direction: true;
+    display: true;
+    dominantBaseline: true;
+    enableBackground: true;
+    fill: true;
+    fillOpacity: true;
+    fillRule: true;
+    filter: true;
+    floodColor: true;
+    floodOpacity: true;
+    imageRendering: true;
+    lightingColor: true;
+    markerEnd: true;
+    markerMid: true;
+    markerStart: true;
+    mask: true;
+    opacity: true;
+    overflow: true;
+    paintOrder: true;
+    pointerEvents: true;
+    shapeRendering: true;
+    stopColor: true;
+    stopOpacity: true;
+    stroke: true;
+    strokeDasharray: true;
+    strokeDashoffset: true;
+    strokeLinecap: true;
+    strokeLinejoin: true;
+    strokeMiterlimit: true;
+    strokeOpacity: true;
+    strokeWidth: true;
+    textAnchor: true;
+    textDecoration: true;
+    textRendering: true;
+    unicodeBidi: true;
+    vectorEffect: true;
+    visibility: true;
+    wordSpacing: true;
+    writingMode: true;
+    cx: true;
+    cy: true;
+    d: true;
+    dx: true;
+    dy: true;
+    fr: true;
+    fx: true;
+    fy: true;
+    points: true;
+    r: true;
+    rx: true;
+    ry: true;
+    transform: true;
+    version: true;
+    viewBox: true;
+    x: true;
+    x1: true;
+    x2: true;
+    y: true;
+    y1: true;
+    y2: true;
+    z: true;
+    accumulate: true;
+    additive: true;
+    allowReorder: true;
+    amplitude: true;
+    attributeName: true;
+    attributeType: true;
+    autoReverse: true;
+    begin: true;
+    bias: true;
+    by: true;
+    calcMode: true;
+    decelerate: true;
+    diffuseConstant: true;
+    divisor: true;
+    dur: true;
+    edgeMode: true;
+    elevation: true;
+    end: true;
+    exponent: true;
+    externalResourcesRequired: true;
+    filterRes: true;
+    filterUnits: true;
+    from: true;
+    in: true;
+    in2: true;
+    intercept: true;
+    k: true;
+    k1: true;
+    k2: true;
+    k3: true;
+    k4: true;
+    kernelMatrix: true;
+    kernelUnitLength: true;
+    keyPoints: true;
+    keySplines: true;
+    keyTimes: true;
+    limitingConeAngle: true;
+    mode: true;
+    numOctaves: true;
+    operator: true;
+    order: true;
+    orient: true;
+    orientation: true;
+    origin: true;
+    pathLength: true;
+    primitiveUnits: true;
+    repeatCount: true;
+    repeatDur: true;
+    restart: true;
+    result: true;
+    rotate: true;
+    scale: true;
+    seed: true;
+    slope: true;
+    spacing: true;
+    specularConstant: true;
+    specularExponent: true;
+    speed: true;
+    spreadMethod: true;
+    startOffset: true;
+    stdDeviation: true;
+    stitchTiles: true;
+    surfaceScale: true;
+    targetX: true;
+    targetY: true;
+    to: true;
+    values: true;
+    xChannelSelector: true;
+    yChannelSelector: true;
+    zoomAndPan: true;
+    accentHeight: true;
+    alphabetic: true;
+    arabicForm: true;
+    ascent: true;
+    bbox: true;
+    capHeight: true;
+    descent: true;
+    fontFamily: true;
+    fontSize: true;
+    fontSizeAdjust: true;
+    fontStretch: true;
+    fontStyle: true;
+    fontVariant: true;
+    fontWeight: true;
+    format: true;
+    g1: true;
+    g2: true;
+    glyphName: true;
+    glyphOrientationHorizontal: true;
+    glyphOrientationVertical: true;
+    glyphRef: true;
+    hanging: true;
+    horizAdvX: true;
+    horizOriginX: true;
+    ideographic: true;
+    kerning: true;
+    lengthAdjust: true;
+    letterSpacing: true;
+    local: true;
+    mathematical: true;
+    overlinePosition: true;
+    overlineThickness: true;
+    panose1: true;
+    refX: true;
+    refY: true;
+    renderingIntent: true;
+    strikethroughPosition: true;
+    strikethroughThickness: true;
+    string: true;
+    systemLanguage: true;
+    tableValues: true;
+    textLength: true;
+    u1: true;
+    u2: true;
+    underlinePosition: true;
+    underlineThickness: true;
+    unicode: true;
+    unicodeRange: true;
+    unitsPerEm: true;
+    vAlphabetic: true;
+    vHanging: true;
+    vIdeographic: true;
+    vMathematical: true;
+    vertAdvY: true;
+    vertOriginX: true;
+    vertOriginY: true;
+    widths: true;
+    xHeight: true;
+    clipPathUnits: true;
+    contentScriptType: true;
+    contentStyleType: true;
+    gradientTransform: true;
+    gradientUnits: true;
+    markerHeight: true;
+    markerUnits: true;
+    markerWidth: true;
+    maskContentUnits: true;
+    maskUnits: true;
+    offset: true;
+    patternContentUnits: true;
+    patternTransform: true;
+    patternUnits: true;
+    preserveAlpha: true;
+    preserveAspectRatio: true;
+    requiredExtensions: true;
+    requiredFeatures: true;
+    viewTarget: true;
+    xlinkActuate: true;
+    xlinkArcrole: true;
+    xlinkHref: true;
+    xlinkRole: true;
+    xlinkShow: true;
+    xlinkTitle: true;
+    xlinkType: true;
+    xmlBase: true;
+    xmlns: true;
+    xmlnsXlink: true;
+    xmlLang: true;
+    xmlSpace: true;
+    for: true;
+    class: true;
+    autofocus: true;
+    children: true;
+    dangerouslySetInnerHTML: true;
+    key: true;
+    ref: true;
+    defaultValue: true;
+    defaultChecked: true;
+    innerHTML: true;
+    suppressContentEditableWarning: true;
+    suppressHydrationWarning: true;
+    valueLink: true;
+    onCaptured: true;
+    precedence: true;
+    blocking: true;
+    autoCorrect: true;
+    autoCapitalize: true;
+    popover: true;
+    popoverTarget: true;
+    popoverTargetAction: true;
+    inert: true;
+    fetchpriority: true;
+    fetchPriority: true;
+    shadowRoot: true;
+    ariaHasPopup: true;
+    ariaLabel: true;
+    ariaLabelledBy: true;
+    about: true;
+    datatype: true;
+    inlist: true;
+    prefix: true;
+    property: true;
+    resource: true;
+    typeof: true;
+    vocab: true;
+    itemProp: true;
+    itemScope: true;
+    itemType: true;
+    itemID: true;
+    itemRef: true;
+    autoSave: true;
+    incremental: true;
+    results: true;
+    security: true;
+    unselectable: true;
+    on: true;
+    option: true;
+    fallback: true;
+};
+declare const VALID_DOM_TESTING_KEYS: string[];
+
+declare const HTML_TAGS: readonly ["div", "span", "a", "p", "ul", "li"];
+declare const SAFE_HTML_TAGS: readonly ["b", "i", "p", "ul", "li", "a", "span", "div", "br", "strong", "em", "u", "code", "pre", "blockquote"];
+declare const DEFAULT_KEYBOARD_CONFIG: Required<TKeyboardConfig>;
+
+declare const __brand: unique symbol;
+type Branded<T, B> = T & {
+    [__brand]: B;
+};
+type TBufferLikeObject = Branded<{
+    type: 'Buffer';
+    data: number[];
+}, 'TBufferLikeObject'>;
+type TAbsoluteURL = Branded<URL, 'TAbsoluteURL'>;
+type TInternalUrl = Branded<string, 'TInternalUrl'>;
+type THexByteString = Branded<string, 'THexByteString'>;
+type TJSONArrayString = Branded<string, 'TJSONArrayString'>;
+type TJSONObjectString = Branded<string, 'TJSONObjectString'>;
+
+type TTypeGuard<T> = (value: unknown) => value is T;
+type TAssert<T> = (value: unknown) => asserts value is T;
+type TAnyFunction = (...args: unknown[]) => unknown;
+type TJSONDataString = TJSONObjectString | TJSONArrayString;
+type TElementLike = {
+    type: string;
+    props: {
+        children?: unknown;
+        [key: string]: unknown;
+    };
+};
+type THTMLTags = (typeof HTML_TAGS)[number];
+
+type TLogType = 'log' | 'warn' | 'error' | 'info' | 'debug' | 'table';
+type THighlighterMap = Record<TLogType, (text: string) => string>;
+type TLogOptions = {
+    enabled?: boolean;
+    highlighters?: THighlighterMap;
+    overrideDev?: boolean;
+};
+type TGetCallerLocationOptions = {
+    preferredIndex?: number;
+    /** Fallback index if preferredIndex is not available (default: 2) */
+    fallbackIndex?: number;
+    /** Whether to get the top-level parent function instead of preferredIndex (default: false) */
+    topParent?: boolean;
+    /** Path prefix to strip from the returned line (default: process.cwd()) */
+    stripPathPrefix?: string;
+};
+type TTableItem = {
+    key?: string;
+    start?: number;
+    end?: number;
+};
+type TProcessedTableItem = {
+    key: string | number;
+    duration: string;
+};
+
+type TPropMap = Record<string, boolean>;
+type TPropCategories = {
+    readonly [category: string]: TPropMap;
+};
+/**
+ * A structural contract for any React component that might have
+ * identification metadata.
+ */
+type TNamedComponent = {
+    displayName?: string;
+    name?: string;
+    /** Support for nested types in Memo/ForwardRef */
+    type?: TNamedComponent;
+};
+
+type TKeyboardActionResult = {
+    isPaste: boolean;
+    isCopy: boolean;
+    isClear: boolean;
+    isAllowedKey: boolean;
+    shouldBlockTyping: boolean;
+};
+type ModifierKey = 'ctrl' | 'meta' | 'alt' | 'shift';
+type TShortcutDefinition = {
+    key: string;
+    modifiers: ModifierKey[];
+};
+type TKeyboardConfig = {
+    allowedKeys?: string[];
+    clearKeys?: string[];
+    copyShortcut?: TShortcutDefinition;
+    pasteShortcut?: TShortcutDefinition;
+};
+type TBaseImageObject = {
+    src: string;
+    [key: string]: unknown;
+};
+/**
+ * Local alias for the native DOM ScrollLogicalPosition.
+ * This resolves the ESLint 'no-undef' error and ensures
+ * compatibility across different TS configurations.
+ */
+type TScrollLogicalPosition = 'center' | 'end' | 'start' | 'nearest';
+type TScrollBehavior = 'auto' | 'smooth';
+type THashScrollOptions = {
+    href: string;
+    behavior?: TScrollBehavior;
+    block?: TScrollLogicalPosition;
+    event?: {
+        preventDefault: () => void;
+    };
+};
+
+type TGenericUrlObject = {
+    pathname?: string | null;
+    query?: Record<string, string | number | boolean | string[] | undefined> | null;
+    hash?: string | null;
+    [key: string]: unknown;
+};
+
+/**
+ * ## 🧩 Available Methods
+ *
+ * - `includes` — Type-safe `Array.includes` helper for union narrowing.
+ * - `createFixedLengthArray` — Ensures arrays have a fixed compile-time length.
+ * - `readAllItems` — Returns a shallow copy of an array.
+ * - `map` — Type-safe wrapper around `Array.map`.
+ * - `forEachUnion` — Handles arrays with union element types safely.
+ * - `forEach` — Standard, type-safe `forEach` wrapper.
+ * - `reduce` — Strictly typed reduction helper.
+ * - `flat` — One-level flattening helper.
+ * - `flatMap` — Safe flatMap alternative with strong typing.
+ * - `filter` — Generic and narrowed type-safe filter.
+ * - `filterNonNullable` — Removes nullish values safely.
+ *
+ * ---
+ * @see {@link CommonUtilsDocs.ArrayUtils}
+ */
+declare class ArrayUtils {
+    /**  @see {@link ArrayUtilsDocs.includes} */
+    static includes<T extends U, U>(arr: ReadonlyArray<T>, el: U): el is T;
+    /**  @see {@link ArrayUtilsDocs.createFixedLengthArray} */
+    static createFixedLengthArray<T>(items: T[], length: number): TFixedLengthArray<T[]>;
+    /**
+     * Returns a shallow copy of an array.
+     *
+     * @typeParam T - Type of array elements.
+     * @param arr - Array to copy.
+     * @returns A new array containing all items.
+     *
+     * @example
+     * const original = [1, 2, 3];
+     * const copy = ArrayUtils.readAllItems(original);
+     * copy.push(4); // Does not affect `original`
+     */
+    static readAllItems<T>(arr: ReadonlyArray<T>): T[];
+    /** 🧠 Safe map wrapper with correct inference */
+    static map<T, U>(arr: ReadonlyArray<T>, fn: (value: T, index: number, array: ReadonlyArray<T>) => U): U[];
+    /**
+     * 🧠 Type-safe forEach for arrays that might be union types.
+     * Helps TypeScript narrow union members while iterating.
+     *
+     * Supports both:
+     * - Single arrays: `T[]`
+     * - Union of arrays: `T[][]`
+     *
+     * @typeParam T - The type of array elements.
+     *
+     * @param arr - The array or array of arrays to iterate over.
+     * @param fn - Callback executed for each element.
+     *
+     * @example
+     * // Single array
+     * const numbers = [1, 2, 3];
+     * ArrayUtils.forEachUnion(numbers, (num, idx) => {
+     *   console.log(num * 2, idx);
+     * });
+     *
+     * @example
+     * // Union of arrays
+     * const arrays: number[][] = [[1, 2], [3, 4]];
+     * ArrayUtils.forEachUnion(arrays, (num, idx) => {
+     *   console.log(num * 2, idx);
+     * });
+     */
+    static forEachUnion<T>(arr: T[] | T[][], fn: (item: T, index: number) => void): void;
+    /** 🧠 Safe forEach wrapper with correct inference */
+    static forEach<T>(arr: ReadonlyArray<T>, fn: (value: T, index: number, array: ReadonlyArray<T>) => void): void;
+    static reduce<T, U>(arr: ReadonlyArray<T>, fn: (accumulator: U, current: T, index: number, array: ReadonlyArray<T>) => U, initialValue: U): U;
+    /** 🧠 Type-safe flat for 1-level nested arrays */
+    static flat<T>(arr: ReadonlyArray<T | T[]>): T[];
+    /** 🧠 Type-safe flatMap */
+    static flatMap<T, U>(arr: ReadonlyArray<T>, fn: (item: T, index: number) => U | U[]): U[];
+    /**
+     * 🧠 Type-safe filter wrapper
+     * Preserves TypeScript type inference.
+     *
+     * @example
+     * const numbers: (number | null)[] = [1, 2, null, 4];
+     * const validNumbers = ArrayUtils.filter(numbers, (n): n is number => n != null);
+     */
+    static filter<T, S extends T>(arr: ReadonlyArray<T>, predicate: (value: T, index: number, array: ReadonlyArray<T>) => value is S): S[];
+    static filter<T>(arr: ReadonlyArray<T>, predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): T[];
+    /**
+     * Shortcut for filtering out null or undefined values.
+     */
+    static filterNonNullable<T>(arr: ReadonlyArray<T | null | undefined>): T[];
+}
+declare const RenamedArrayMethods: {
+    arrayIncludes: typeof ArrayUtils.includes;
+    arrayMap: typeof ArrayUtils.map;
+    arrayFilter: typeof ArrayUtils.filter;
+    arrayFlat: typeof ArrayUtils.flat;
+    arrayReduce: typeof ArrayUtils.reduce;
+    arrayForEach: typeof ArrayUtils.forEach;
+    arrayFlatMap: typeof ArrayUtils.flatMap;
+    arrayFilterNonNullable: typeof ArrayUtils.filterNonNullable;
+};
+declare const arrayMap: typeof ArrayUtils.map;
+declare const arrayFilter: typeof ArrayUtils.filter;
+declare const arrayIncludes: typeof ArrayUtils.includes;
+declare const arrayReduce: typeof ArrayUtils.reduce;
+declare const arrayFlat: typeof ArrayUtils.flat;
+declare const arrayFlatMap: typeof ArrayUtils.flatMap;
+declare const arrayForEach: typeof ArrayUtils.forEach;
+declare const arrayFilterNonNullable: typeof ArrayUtils.filterNonNullable;
+
+/**
+ * ## 🧩 Available Methods
+ *
+ * - `keys` — Returns the keys of an object with full type inference.
+ * - `entries` — Returns typed key-value pairs of an object.
+ * - `fromEntries` — Builds a typed object from key-value entry tuples.
+ * - `values` — Returns the values of an object with inferred types.
+ * - `has` — Checks if a nested property exists via dot notation.
+ * - `get` — Safely retrieves a nested property using a dot path.
+ * - `set` — Safely sets a nested property using a dot path.
+ *
+ * ---
+ * @see {@link CommonUtilsDocs.ObjectUtils}
+ */
+declare class ObjectUtils {
+    /**
+     * Returns the keys of an object while protecting key inference.
+     *
+     * @template Obj - The object type
+     * @param {Obj} obj - The object to extract keys from
+     */
+    static keys<Obj extends object>(obj: Obj): (keyof Obj)[];
+    /**
+     * Returns the key-value pairs of an object while protecting type inference.
+     *
+     * @template T - The object type
+     * @param {T} obj - The object to extract key-value pairs from
+     */
+    static entries<T extends Record<string, unknown>>(obj: T): [keyof T, T[keyof T]][];
+    /**
+     * Constructs an object from an array of entries with type safety.
+     */
+    static fromEntries<K extends string | number | symbol = string, // default key type
+    V = unknown>(entries: [K, V][]): Record<K, V>;
+    /**
+     * Returns the values of an object while protecting type inference.
+     *
+     * @template Obj - The object type
+     * @param {Obj} obj - The object to extract values from
+     */
+    static values<Obj extends object>(obj: Obj): Obj[keyof Obj][];
+    /**
+     * Checks if a nested property exists in an object using dot notation.
+     * @param obj - The object to check.
+     * @param path - Dot-separated path like 'user.profile.name'
+     */
+    static has<Obj extends object>(obj: Obj, path: string): boolean;
+    /**
+     * Safely gets a nested property from an object using dot notation.
+     * @param obj - The object to access.
+     * @param path - Dot-separated path like 'user.profile.name'
+     */
+    static get<Obj extends object, Path extends string>(obj: Obj, path: Path): unknown;
+    /**
+     * Safely sets a nested property on an object using dot notation.
+     * Creates intermediate objects as needed.
+     * @param obj - The object to modify.
+     * @param path - Dot-separated path like 'user.profile.name'
+     * @param value - The value to set
+     */
+    static set<Obj extends object>(obj: Obj, path: string, value: unknown): void;
+}
+declare const RenamedObjectMethods: {
+    objectKeys: typeof ObjectUtils.keys;
+    objectEntries: typeof ObjectUtils.entries;
+    objectFromEntries: typeof ObjectUtils.fromEntries;
+    objectValues: typeof ObjectUtils.values;
+    objectHas: typeof ObjectUtils.has;
+    objectGet: typeof ObjectUtils.get;
+    objectSet: typeof ObjectUtils.set;
+};
+declare const objectKeys: typeof ObjectUtils.keys;
+declare const objectEntries: typeof ObjectUtils.entries;
+declare const objectFromEntries: typeof ObjectUtils.fromEntries;
+declare const objectValues: typeof ObjectUtils.values;
+declare const objectHas: typeof ObjectUtils.has;
+declare const objectGet: typeof ObjectUtils.get;
+declare const objectSet: typeof ObjectUtils.set;
+
+declare const isNull: TTypeGuard<null>;
+declare const isUndefined: TTypeGuard<undefined>;
+declare const isDefined: TTypeGuard<unknown>;
+declare const isNil: TTypeGuard<null | undefined>;
+declare const isFunction: TTypeGuard<TAnyFunction>;
+declare const isObject: TTypeGuard<object>;
+declare const isArray: TTypeGuard<unknown[]>;
+declare const isMap: TTypeGuard<Map<unknown, unknown>>;
+declare const isSet: TTypeGuard<Set<unknown>>;
+/**
+ * Checks if the given value is an instance of `WeakMap`.
+ *
+ * A **WeakMap** is a special kind of `Map` where:
+ * - **Keys must be objects** (not primitives)
+ * - Keys are **held weakly**, meaning if there are no other references to the key object,
+ *   it can be garbage-collected automatically
+ * - It does **not** support iteration (`.keys()`, `.values()`, `.entries()` are not available)
+ * - It is ideal for **storing private metadata** about objects without preventing cleanup
+ *
+ * 🧠 Useful for:
+ * - Caching computed data for objects
+ * - Associating data with DOM elements without memory leaks
+ *
+ * 📚 **Learn more:**
+ * - [MDN — WeakMap](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap)
+ *
+ * @example
+ * ```ts
+ * const weakMap = new WeakMap<object, number>();
+ * const obj = {};
+ *
+ * weakMap.set(obj, 42);
+ *
+ * ReferenceTypeGuards.isWeakMap(weakMap); // true
+ * ReferenceTypeGuards.isWeakMap(new Map()); // false
+ * ReferenceTypeGuards.isWeakMap({}); // false
+ * ```
+ */
+declare const isWeakMap: TTypeGuard<WeakMap<object, unknown>>;
+/**
+ * Checks if the given value is an instance of `WeakSet`.
+ *
+ * A **WeakSet** is a special kind of `Set` where:
+ * - It can only store **object values** (no primitives)
+ * - Objects are **held weakly**, meaning if there are no other references to an object,
+ *   it can be garbage-collected automatically
+ * - It is **not iterable** — you can’t get its contents or size
+ * - Commonly used to track object presence without memory leaks
+ *
+ * 🧠 Useful for:
+ * - Tracking which objects have been processed
+ * - Marking objects as “seen” in caches or graph traversals
+ *
+ * 📚 **Learn more:**
+ * - [MDN — WeakSet](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet)
+ *
+ * @example
+ * ```ts
+ * const weakSet = new WeakSet<object>();
+ * const obj = {};
+ *
+ * weakSet.add(obj);
+ *
+ * ReferenceTypeGuards.isWeakSet(weakSet); // true
+ * ReferenceTypeGuards.isWeakSet(new Set()); // false
+ * ReferenceTypeGuards.isWeakSet([]); // false
+ * ```
+ */
+declare const isWeakSet: TTypeGuard<WeakSet<object>>;
+declare function isInstanceOf<T extends object, Args extends unknown[]>(value: unknown, constructor: new (...args: Args) => T): value is T;
+
+declare const isNumber: TTypeGuard<number>;
+declare const isInteger: TTypeGuard<number>;
+declare const isString: TTypeGuard<string>;
+declare const isNonEmptyString: TTypeGuard<string>;
+declare const isBoolean: TTypeGuard<boolean>;
+/**
+ * Checks if the value is a bigint.
+ *
+ * @example
+ * ```ts
+ * PrimitiveTypeGuards.isBigInt(123n); // true
+ * PrimitiveTypeGuards.isBigInt(123); // false
+ * ```
+ */
+declare const isBigInt: TTypeGuard<bigint>;
+/**
+ * Checks whether a value is a `symbol`.
+ *
+ * In JavaScript, a `symbol` is a unique and immutable primitive value that can be used as a key
+ * for object properties. Each symbol is guaranteed to be unique, even if two symbols have the same
+ * description.
+ *
+ * Key points:
+ * - Symbols are often used to add unique property keys to objects without risk of name collisions.
+ * - `typeof value === 'symbol'` is used to check if a value is a symbol.
+ *
+ * @example
+ * ```ts
+ * const sym1 = Symbol('foo');
+ * const sym2 = Symbol('foo');
+ *
+ * isSymbol(sym1); // true
+ * isSymbol(sym2); // true
+ * isSymbol('foo'); // false
+ *
+ * const obj = { [sym1]: 123 };
+ * console.log(obj[sym1]); // 123
+ * ```
+ */
+declare const isSymbol: TTypeGuard<symbol>;
+declare const isPrimitive: (value: unknown) => value is string | number | boolean;
+
+/**
+ * ## 🧩 isInArray — Type Guard Factory for Array Membership
+ *
+ * Creates a **type guard** that checks whether a value exists in a given array.
+ * Internally, it uses a `Set` for **O(1) lookup**, making repeated checks more efficient.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Verify that a value is included in a predefined array of allowed values.
+ * - 🔹 Provide a **TypeScript type guard** so that the compiler can narrow types.
+ * - 🔹 Optimized for repeated checks by creating a `Set` once per factory call.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * // Store the returned type guard for repeated checks
+ * const isAllowedColor = isInArray(['red', 'green', 'blue'] as const);
+ * isAllowedColor('red');   // true
+ * isAllowedColor('yellow'); // false
+ *
+ * const isAllowedNumber = isInArray([1, 2, 3] as const);
+ * isAllowedNumber(2); // true
+ * isAllowedNumber(4); // false
+ *
+ * // Or invoke inline without storing the guard
+ * isInArray(['red', 'green', 'blue'] as const)('green'); // true
+ * ```
+ *
+ *
+ * ---
+ *
+ * ### 📌 Notes
+ * - This is a **factory function**: you first pass the array, then use the returned function as a type guard.
+ * - The returned guard checks for `undefined` and only returns `true` if the value exists in the array.
+ * - Use this guard when you need **repeated membership checks** on a fixed array of values.
+ *
+ * @typeParam T - The type of elements in the target array.
+ * @param target - The array of allowed values.
+ * @returns A type guard function that narrows `unknown` to `T | undefined`.
+ */
+declare const isInArray: <T>(target: readonly T[]) => TTypeGuard<T | undefined>;
+/**
+ * Checks whether a value is a valid key of a given object.
+ *
+ * This function returns a **TypeScript type guard**, allowing you to safely
+ * access object properties with dynamic keys while retaining full type safety.
+ *
+ * Key points:
+ * - Works with `string`, `number`, and `symbol` keys.
+ * - Returns a type guard `(key: unknown) => key is keyof T`.
+ * - Useful for runtime checks before accessing object properties dynamically.
+ *
+ * @typeParam T - The type of the target object.
+ * @param obj - The object whose keys should be checked against.
+ * @param key - The value to check if it is a valid key of `obj`.
+ * @returns `true` if `key` exists in `obj`; otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * const user = { id: 1, name: 'Alice', email: 'alice@example.com' };
+ *
+ * isKeyOfObject(user, 'name');     // true  ✅ 'name' is a valid key
+ * isKeyOfObject(user, 'password'); // false ❌ 'password' is not a valid key
+ * ```
+ */
+declare const isKeyOfObject: <T extends object>(obj: T) => TTypeGuard<keyof T>;
+/**
+ * Type guard that checks whether a given unknown value is an object
+ * and contains a specific property key.
+ *
+ * Unlike `isKeyOfObject(obj)(key)` which only narrows the *key* type,
+ * this guard narrows the *object* itself. After calling this function,
+ * TypeScript knows that:
+ *
+ *   - `obj` is a non-null object
+ *   - `obj` contains the property `key`
+ *   - you can safely access `obj[key]`
+ *
+ * This is the preferred guard to use when you need to safely access
+ * dynamic or unknown object properties, such as when validating
+ * external or untyped data (e.g., errors from Supabase or fetch APIs).
+ *
+ * @example
+ * if (isKeyInObject("message")(err)) {
+ *   console.log(err.message); // fully typed and safe
+ * }
+ *
+ * @param key - The property key to check for.
+ * @returns A type guard that checks if an unknown value is an object
+ *          containing the specified key.
+ */
+declare const isKeyInObject: <K extends PropertyKey>(key: K) => (obj: unknown) => obj is Record<K, unknown>;
+/**
+ * ## 🧩 isKeyOfArray — Type Guard for Allowed Primitive Keys
+ *
+ * Checks if a value is one of the keys in a given readonly array of allowed keys.
+ * This is a **type-safe type guard** for primitive keys (`string | number | symbol`)
+ * that exist in a known array. It is useful for narrowing a value to a specific set
+ * of literal keys at runtime.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Only works with **primitive keys**: `string`, `number`, or `symbol`.
+ * - 🔹 Returns a **TypeScript type guard** (`key is T[number]`) for type inference.
+ * - 🔹 Uses `Array.includes` to check for membership in the allowed keys array.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * const allowedKeys = ['id', 'name', 'age'] as const;
+ * const key: unknown = 'name';
+ *
+ * if (isKeyOfArray(allowedKeys)(key)) {
+ *   // ✅ TypeScript now knows `key` is 'id' | 'name' | 'age'
+ *   console.log(key); // 'name'
+ * }
+ *
+ * const invalidKey: unknown = 'email';
+ * isKeyOfArray(allowedKeys)(invalidKey); // false
+ *
+ * // Inline usage
+ * isKeyOfArray(['x', 'y', 'z'] as const)('x'); // true
+ * isKeyOfArray(['x', 'y', 'z'] as const)('a'); // false
+ * ```
+ *
+ * ---
+ *
+ * @typeParam T - A readonly tuple or array of allowed keys.
+ * @param keys - The array of valid keys.
+ * @returns A type guard function that returns `true` if the value is included in `keys`.
+ */
+declare const isKeyOfArray: <T extends readonly (string | number | symbol)[]>(keys: T) => TTypeGuard<T[number]>;
+/**
+ * ## 🧩 isArrayOf — Type Guard for Arrays of Specific Types
+ *
+ * Checks if a value is an array where **all elements satisfy a given type guard**.
+ * This allows TypeScript to narrow types safely and perform runtime validation.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Verify that a value is an array.
+ * - 🔹 Ensure that **every element** matches a specific type guard.
+ * - 🔹 Enable **type-safe operations** on arrays after the check.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * import { isArrayOf, isNumber, isString } from '@/utils/guards/composite';
+ *
+ * const arr1: unknown = [1, 2, 3];
+ * if (isArrayOf(isNumber, arr1)) {
+ *   // ✅ arr1 is now typed as number[]
+ *   const sum = arr1.reduce((a, b) => a + b, 0);
+ * }
+ *
+ * const arr2: unknown = ['a', 'b', 3];
+ * isArrayOf(isString, arr2); // false
+ * ```
+ *
+ * ---
+ *
+ * ### 📌 Notes
+ * - The **type guard is passed as a parameter**, making this function highly composable.
+ * - Use for arrays of primitives or arrays of objects validated by another type guard.
+ *
+ * @typeParam T - Type of array elements.
+ * @param typeGuard - Type guard function for the array elements.
+ * @param value - Value to validate.
+ * @returns `true` if `value` is an array and all elements pass the type guard.
+ */
+declare const isArrayOf: <T>(typeGuard: TTypeGuard<T>, value: unknown) => value is T[];
+/**
+ * ## 🧩 isRecordOf — Type Guard for Objects with Uniform Value Types
+ *
+ * Checks if a value is an object where **all property values satisfy a given type guard**.
+ * Useful for ensuring that a record has uniform value types and for type-safe access.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Verify that a value is an object (non-null).
+ * - 🔹 Ensure that every property value passes a provided type guard.
+ * - 🔹 Enable **type-safe operations** on objects with consistent value types.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * import { isRecordOf, isNumber, isBoolean } from '@/utils/guards/composite';
+ *
+ * const obj1: unknown = { a: 1, b: 2 };
+ * if (isRecordOf(obj1, isNumber)) {
+ *   // ✅ obj1 is now typed as Record<string, number>
+ *   const sum = Object.values(obj1).reduce((a, b) => a + b, 0);
+ * }
+ *
+ * const obj2: unknown = { a: 1, b: '2' };
+ * isRecordOf(obj2, isNumber); // false
+ *
+ * const obj3: unknown = { foo: true, bar: false };
+ * isRecordOf(obj3, isBoolean); // true
+ * ```
+ *
+ * ---
+ *
+ * ### 📌 Notes
+ * - Works only with **plain objects** (non-null) and string keys.
+ * - Supports composability by accepting any type guard for property values.
+ *
+ * @typeParam V - Type of the values in the record.
+ * @param value - Value to check.
+ * @param typeGuard - Type guard function applied to each property value.
+ * @returns `true` if `value` is an object and all property values pass the type guard.
+ */
+declare const isRecordOf: <V>(value: unknown, typeGuard: TTypeGuard<V>) => value is Record<string, V>;
+/**
+ * ## 🔑 hasDefinedKeys — Type Guard Factory for Required Object Properties
+ *
+ * Creates a type guard that ensures an object contains a specific set of **required keys**
+ * and that their values are **defined** (not `undefined`).
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Validate that an object implements a specific interface or shape.
+ * - 🔹 Ensure critical properties exist and are not `undefined`.
+ * - 🔹 Narrow an `unknown` object to a specific type `T` for safe property access.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * import { hasDefinedKeys } from '@/utils/guards/composite';
+ *
+ * interface User { id: string; name: string; age?: number; }
+ *
+ * // Create a guard for required fields
+ * const isUser = hasDefinedKeys<User>(['id', 'name']);
+ *
+ * const data: unknown = { id: 'u1', name: 'Alice' };
+ *
+ * if (isUser(data)) {
+ *   // ✅ data is now typed as User
+ *   console.log(data.id, data.name);
+ * }
+ *
+ * const invalid: unknown = { id: 'u2' };
+ * isUser(invalid); // false (missing 'name')
+ * ```
+ *
+ * ---
+ *
+ * ### 📌 Notes
+ * - This is a **factory function**; it returns a new type guard function.
+ * - It checks for the existence of the key *and* that the value is not `undefined`.
+ * - Ideal for validating API responses or configuration objects.
+ *
+ * @typeParam T - The target object type to validate against.
+ * @param requiredKeys - An array of keys from type `T` that must be present and defined.
+ * @returns A type guard function that returns `true` if all `requiredKeys` are found and defined.
+ */
+declare const hasDefinedKeys: <T extends object>(requiredKeys: (keyof T)[]) => ((value: unknown) => value is T);
+
+/**
+ * Checks if a value is a **Buffer-like object**.
+ *
+ * A Buffer-like object is an object with the following shape:
+ * ```ts
+ * {
+ *   type: 'Buffer';
+ *   data: number[];
+ * }
+ * ```
+ *
+ * This guard validates:
+ * - ✅ The value is a non-null object
+ * - ✅ The `type` property exists and is exactly `'Buffer'`
+ * - ✅ The `data` property exists and is an array of numbers
+ *
+ * ---
+ * ### Key Points
+ * - Uses `isObject` to ensure the value is an object
+ * - Uses `isArrayOf(isNumber)` to check that `data` contains only numbers
+ * - This is a **composite type guard** because it combines multiple primitive/reference checks
+ *
+ * ---
+ * ### Example Usage
+ * ```ts
+ * const buf = { type: 'Buffer', data: [1, 2, 3] };
+ * const notBuf = { type: 'Buffer', data: ['a', 'b'] };
+ *
+ * isBufferLikeObject(buf); // true
+ * isBufferLikeObject(notBuf); // false
+ * ```
+ *
+ * ---
+ * @param value - The value to check
+ * @returns `true` if the value is a Buffer-like object, otherwise `false`
+ */
+declare const isBufferLikeObject: TTypeGuard<TBufferLikeObject>;
+/**
+ * ## 🎨 isRGBTuple — Type Guard for Color Values
+ *
+ * Validates if a value is an array of exactly three numbers, each representing
+ * a standard 8-bit color channel (0-255).
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Verify the value is an array with a `length` of 3.
+ * - 🔹 Ensure every element is a number within the range [0, 255].
+ * - 🔹 Provide a **TypeScript type guard** (`TRGB`) for safe tuple access.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * isRGBTuple([255, 0, 0]);     // true (Red)
+ * isRGBTuple([0, 256, 0]);     // false (Out of range)
+ * isRGBTuple([128, 128]);      // false (Wrong length)
+ * ```
+ */
+declare const isRGBTuple: TTypeGuard<TRGB>;
+/**
+ * ## 📞 isPhoneNumber — Type Guard for International Formats
+ *
+ * Validates whether a string matches common phone number patterns, including
+ * US, EU, and generic international formats.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Test strings against a set of optimized regular expressions.
+ * - 🔹 Support multiple geographical formats (US/EU/Global).
+ * - 🔹 Ensure the value is a non-empty string before testing.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * isPhoneNumber('+1-202-555-0101'); // true
+ * isPhoneNumber('06 12 34 56 78');    // true
+ * isPhoneNumber('123-abc');           // false
+ * ```
+ */
+declare const isPhoneNumber: TTypeGuard<string>;
+/**
+ * ## 📧 isEmail — Type Guard for Email Addresses
+ *
+ * Validates if a string conforms to a standard email address format using
+ * a robust regular expression.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Verify the string contains a valid local part, '@' symbol, and domain.
+ * - 🔹 Perform a high-speed check suitable for form validation or data cleaning.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * isEmail('hello@world.com'); // true
+ * isEmail('invalid-email@');   // false
+ * isEmail(12345);              // false
+ * ```
+ */
+declare const isEmail: TTypeGuard<string>;
+
+/**
+ * ## 🧩 isValidUrl — Type Guard for Absolute URLs
+ *
+ * Checks whether a given string is a valid absolute URL according to the
+ * browser's `URL` constructor. Returns `true` if the string can be parsed
+ * as a valid URL, otherwise `false`.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Ensures the string is non-empty and a valid URL.
+ * - 🔹 Provides a **TypeScript type guard** (`url is string`) for safe narrowing.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * isValidUrl('https://example.com'); // true
+ * isValidUrl('ftp://example.com');   // true
+ * isValidUrl('not a url');           // false
+ * isValidUrl('');                     // false
+ * ```
+ *
+ * ---
+ *
+ * @param url - The value to validate as a URL.
+ * @returns `true` if `url` is a non-empty valid absolute URL string.
+ */
+declare const isAbsoluteUrl: TTypeGuard<TAbsoluteURL>;
+/**
+ * ## 🏠 isInternalUrl — Type Guard for Same-Origin or Relative Links
+ *
+ * Checks if a value is a valid internal URL. A URL is considered "internal" if it
+ * is a relative path (starts with `/`) or an absolute URL that matches the
+ * current window's origin (same domain).
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Distinguish between internal navigation and external outbound links.
+ * - 🔹 Validate relative paths for client-side routing.
+ * - 🔹 Ensure a URL belongs to the current application's hostname.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * // Assuming current origin is 'https://myapp.com'
+ * isInternalUrl('/dashboard');              // true
+ * isInternalUrl('https://myapp.com'); // true
+ * isInternalUrl('https://google.com');      // false
+ * isInternalUrl('mailto:test@test.com');    // false
+ * ```
+ *
+ * ---
+ *
+ * ### ⚠️ Environment Note
+ * - This guard requires a **browser environment** (`window.location`).
+ * - In SSR or Node.js environments, it will consistently return `false`.
+ *
+ * ---
+ *
+ * @param url - The value to validate as an internal link.
+ * @returns `true` if `url` is a non-empty string belonging to the current origin.
+ */
+declare const isInternalUrl: TTypeGuard<TInternalUrl>;
+
+/**
+ * Checks if the value is a camelCase string.
+ *
+ * By default, this checks that:
+ * - The string starts with a lowercase letter
+ * - Only contains alphanumeric characters
+ * - No separators like `_`, `-`, or spaces
+ *
+ * You can think of this in terms of the `TCamelCase` type:
+ * ```ts
+ * type Example = TCamelCase<'my-variable'>; // 'myVariable'
+ * ```
+ *
+ * Optionally, camelCase strings may preserve consecutive uppercase letters
+ * using `TCamelCaseOptions['preserveConsecutiveUppercase']`. For example:
+ * ```ts
+ * type Example1 = TCamelCase<'FOO-BAR'>; // 'fooBAR' if preserveConsecutiveUppercase = true
+ * type Example2 = TCamelCase<'FOO-BAR', { preserveConsecutiveUppercase: false }>; // 'fooBar'
+ * ```
+ *
+ * @example
+ * ```ts
+ * TypeGuardUtils.isCamelCase('myVariable'); // true
+ * TypeGuardUtils.isCamelCase('myVariable2'); // true
+ * TypeGuardUtils.isCamelCase('MyVariable'); // false (starts with uppercase)
+ * TypeGuardUtils.isCamelCase('my_variable'); // false (contains underscore)
+ * TypeGuardUtils.isCamelCase('fooBAR'); // true if preserveConsecutiveUppercase is considered
+ * ```
+ */
+declare const isCamelCase: TTypeGuard<TCamelCase<string>>;
+declare const isSnakeCase: TTypeGuard<TSnakeCase<string>>;
+declare const isKebabCase: TTypeGuard<TKebabCase<string>>;
+declare const isJSONArrayString: TTypeGuard<TJSONArrayString>;
+declare const isJSONObjectString: TTypeGuard<TJSONObjectString>;
+declare const isHTMLString: TTypeGuard<string>;
+/**
+ * Checks whether a string is a valid hexadecimal representation.
+ *
+ * A hexadecimal string consists of characters 0–9, a–f, or A–F,
+ * and is often used for binary data encoding, color codes, cryptographic hashes, etc.
+ *
+ * Key points:
+ * - The value must be a non-empty string.
+ * - Only characters `[0-9a-fA-F]` are allowed.
+ * - The length must be even, unless `expectedLength` is provided.
+ * - If `expectedLength` is specified, the string must match that exact length.
+ * - Returns a TypeScript type guard, so it narrows the type to `string` when used.
+ *
+ * Example usage:
+ * ```ts
+ * isHexString("0a1b2c"); // true
+ * isHexString("0a1b2z"); // false (invalid character 'z')
+ * isHexString("0a1b2c", 6); // true
+ * isHexString("0a1b2c", 8); // false (length mismatch)
+ * ```
+ *
+ * Use case:
+ * - Validating inputs for cryptographic functions.
+ * - Ensuring a string is a valid hex color code.
+ * - Checking serialized binary data in hexadecimal format.
+ *
+ * @param value - The value to check.
+ * @param expectedLength - Optional length the hex string must match exactly.
+ * @returns `true` if `value` is a valid hexadecimal string; otherwise `false`.
+ *
+ * @typeParam T - N/A
+ */
+declare const isHexByteString: (expectedLength?: number) => TTypeGuard<THexByteString>;
+/**
+ * Checks whether a string contains valid JSON.
+ *
+ * This type guard ensures that:
+ * - The value is a non-empty string.
+ * - The string can be parsed successfully using `JSON.parse()`.
+ *
+ * Key points:
+ * - Returns a TypeScript type guard, narrowing the type to `string`.
+ * - Invalid JSON or non-string values return `false`.
+ * - Useful for validating dynamic input or API responses.
+ *
+ * Example usage:
+ * ```ts
+ * isJsonString('{"foo": 1}'); // true
+ * isJsonString('["a", "b"]'); // true
+ * isJsonString('not json');   // false
+ * isJsonString('');           // false
+ * ```
+ *
+ * Use case:
+ * - Safely validate strings before parsing them as JSON.
+ * - Guard input data in APIs, configuration files, or user inputs.
+ *
+ * @param value - The value to validate.
+ * @returns `true` if `value` is a string containing valid JSON; otherwise `false`.
+ */
+declare const isJsonString: TTypeGuard<TJSONDataString>;
+
+declare const CoreTypeGuards: {
+    readonly isString: TTypeGuard<string>;
+    readonly isNumber: TTypeGuard<number>;
+    readonly isBoolean: TTypeGuard<boolean>;
+    readonly isBigInt: TTypeGuard<bigint>;
+    readonly isNil: TTypeGuard<null | undefined>;
+    readonly isDefined: TTypeGuard<unknown>;
+    readonly isInteger: TTypeGuard<number>;
+    readonly isNonEmptyString: TTypeGuard<string>;
+    readonly isSymbol: TTypeGuard<symbol>;
+    readonly isPrimitive: (value: unknown) => value is string | number | boolean;
+    readonly isNull: TTypeGuard<null>;
+    readonly isFunction: TTypeGuard<TAnyFunction>;
+    readonly isObject: TTypeGuard<object>;
+    readonly isArray: TTypeGuard<unknown[]>;
+    readonly isMap: TTypeGuard<Map<unknown, unknown>>;
+    readonly isSet: TTypeGuard<Set<unknown>>;
+    readonly isWeakMap: TTypeGuard<WeakMap<object, unknown>>;
+    readonly isWeakSet: TTypeGuard<WeakSet<object>>;
+    readonly isUndefined: TTypeGuard<undefined>;
+    readonly isInstanceOf: typeof isInstanceOf;
+};
+declare const FormatTypeGuards: {
+    readonly isEmail: TTypeGuard<string>;
+    readonly isPhone: TTypeGuard<string>;
+    readonly isUrlAbsolute: TTypeGuard<TAbsoluteURL>;
+    readonly isUrlInternal: TTypeGuard<TInternalUrl>;
+    readonly isJsonString: TTypeGuard<TJSONDataString>;
+    readonly isHTMLString: TTypeGuard<string>;
+    readonly isCamelCase: TTypeGuard<string>;
+    readonly isSnakeCase: TTypeGuard<string>;
+    readonly isKebabCase: TTypeGuard<string>;
+    readonly isHexByteString: (expectedLength?: number) => TTypeGuard<THexByteString>;
+    readonly isJSONObjectString: TTypeGuard<TJSONObjectString>;
+    readonly isJSONArrayString: TTypeGuard<TJSONArrayString>;
+    readonly isRGBTuple: TTypeGuard<TRGB>;
+    readonly isBufferLikeObject: TTypeGuard<TBufferLikeObject>;
+};
+declare const CollectionTypeGuards: {
+    readonly isArrayOf: <T>(typeGuard: TTypeGuard<T>, value: unknown) => value is T[];
+    readonly isRecordOf: <V>(value: unknown, typeGuard: TTypeGuard<V>) => value is Record<string, V>;
+    readonly isKeyOfObject: <T extends object>(obj: T) => TTypeGuard<keyof T>;
+    readonly isKeyInObject: <K extends PropertyKey>(key: K) => (obj: unknown) => obj is Record<K, unknown>;
+    readonly isKeyOfArray: <T extends readonly (string | number | symbol)[]>(keys: T) => TTypeGuard<T[number]>;
+    readonly isInArray: <T>(target: readonly T[]) => TTypeGuard<T | undefined>;
+    readonly hasKeys: <T extends object>(requiredKeys: (keyof T)[]) => ((value: unknown) => value is T);
+};
+
+/**
+ * Validates if a property is a standard DOM/SVG attribute or event handler.
+ * Memoized to ensure O(1) lookups after the first check.
+ */
+declare const isPropValid: (arg: string) => boolean;
+/**
+ * Type guard to check if a value is a valid DOM property string.
+ */
+declare const isDOMPropKey: TTypeGuard<string>;
+/**
+ * Checks if a key-value entry represents a valid DOM property for a specific element.
+ */
+declare const isDOMEntry: <TElement extends ElementType>(entry: [PropertyKey, unknown]) => entry is [Extract<keyof ComponentPropsWithoutRef<TElement>, string>, unknown];
+
+/**
+ * ## 🌳 isValidReactNode — Type Guard for all Renderable Content
+ *
+ * Validates if a value is a valid `ReactNode` (anything React can render).
+ * This includes primitives, JSX elements, Portals, and recursive arrays of nodes.
+ */
+declare const isValidReactNode: TTypeGuard<ReactNode>;
+/**
+ * ## 🌳 isReactElement — Type Guard for JSX Elements
+ *
+ * Validates if a value is a `ReactElement` (JSX).
+ * Uses React's internal security checks to ensure the object is a legitimate element.
+ */
+declare const isReactElement: TTypeGuard<ReactElement>;
+/**
+ * ## 🌳 isFragment — Type Guard for React Fragments
+ *
+ * Narrow check to determine if a React Element is specifically a `<React.Fragment>`.
+ */
+declare const isFragment: TTypeGuard<ReactElement>;
+/**
+ * ## 🌳 hasOnClick — Type Guard for Interactive Elements
+ *
+ * Checks if a React Element has a valid `onClick` function in its props.
+ * Useful for safely injecting behavior during `React.cloneElement`.
+ *
+ * ---
+ * ### 📘 Example Usage
+ * ```ts
+ * if (hasOnClick(child)) {
+ *   return React.cloneElement(child, {
+ *     onClick: (e) => { console.log('Clicked!'); child.props.onClick(e); }
+ *   });
+ * }
+ * ```
+ */
+declare const hasOnClick: TTypeGuard<ReactElement<{
+    onClick?: (e: MouseEvent<HTMLElement>) => void;
+}>>;
+/**
+ * ## 🌳 isElementLike — Type Guard for Duck-Typed Elements
+ *
+ * Checks if an object "looks like" a React element (has type and props).
+ * Useful for processing JSON-serialized components or objects from other environments.
+ */
+declare const isElementLike: TTypeGuard<TElementLike>;
+/**
+ * ## 🌳 isElementOfType — Type Guard for Specific HTML Tags
+ *
+ * Validates if an element-like object matches a specific set of allowed HTML tags.
+ *
+ * @param allowedTypes - An array or string of tags to validate against (e.g., 'div' or ['a', 'button']).
+ */
+declare const isElementOfType: <T extends THTMLTags>(element: unknown, allowedTypes: THTMLTags) => element is {
+    type: THTMLTags;
+    props: object;
+};
+/**
+ * ## 🌳 hasNameMetadata — Type Guard for Named Components
+ *
+ * Checks if a React component type has identifying metadata like `displayName` or `name`.
+ * Essential for debugging utilities or logging component names.
+ */
+declare const hasNameMetadata: (type: unknown) => type is TNamedComponent;
+
+/**
+ * ## 🧩 isRef — Type Guard for React Refs
+ *
+ * Validates if a value is a valid React Ref, covering both **Functional (Callback) Refs**
+ * and **Object Refs** (created via `useRef` or `createRef`).
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * isRef((el) => { console.log(el) }); // true (Callback Ref)
+ * isRef({ current: document.createElement('div') }); // true (Object Ref)
+ * ```
+ *
+ * @template T - The type of the element or value being referenced.
+ */
+declare const isRef: <T>(value: unknown) => value is Ref<T>;
+/**
+ * ## 🧩 isRefObject — Type Guard for Persistent Ref Objects
+ *
+ * Specifically checks if a value is a `RefObject` (an object containing a `.current` property).
+ * This effectively narrows the type away from Callback Refs.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * const myRef = useRef(null);
+ * if (isRefObject(myRef)) {
+ *   // ✅ Safely access myRef.current
+ * }
+ * ```
+ */
+declare const isRefObject: <T>(ref: Ref<T>) => ref is RefObject<T | null>;
+/**
+ * ## 🧩 isPromise — Type Guard for Async Thenables
+ *
+ * Checks if a value is a `Promise` or a "Thenable" object by validating
+ * the existence of a `.then()` method.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * if (isPromise(data)) {
+ *   data.then((res) => console.log(res));
+ * }
+ * ```
+ */
+declare const isPromise: <T>(value: unknown) => value is Promise<T>;
+/**
+ * ## 🧩 isReactPortal — Type Guard for Portals
+ *
+ * Checks if a value is a `ReactPortal` created via `ReactDOM.createPortal`.
+ * Validates the existence of the internal `containerInfo` property.
+ */
+declare const isReactPortal: TTypeGuard<ReactPortal>;
+/**
+ * ## 🧩 hasChildren — Type Guard for Prop Objects with Children
+ *
+ * Validates if an object contains a defined `children` property.
+ * Useful for verifying props in HOCs or wrapper components.
+ */
+declare const hasChildren: (value: unknown) => value is {
+    children: ReactNode;
+};
+/**
+ * ## 🧩 isComponentType — Type Guard for React Components
+ *
+ * Determines if a value is a valid React Component (Function Component or Class Component).
+ * For classes, it validates the existence of a `render` method on the prototype.
+ */
+declare const isComponentType: TTypeGuard<ComponentType<unknown>>;
+/**
+ * ## 🧩 isForwardRef — Type Guard for ForwardRef Components
+ *
+ * Validates if a component is wrapped in `React.forwardRef` by checking
+ * the internal `$$typeof` symbol.
+ */
+declare const isForwardRef: TTypeGuard<ForwardRefExoticComponent<object>>;
+
+declare const ReactTypeGuards: {
+    readonly isRef: <T>(value: unknown) => value is react.Ref<T>;
+    readonly isRefObject: <T>(ref: react.Ref<T>) => ref is react.RefObject<T | null>;
+    readonly isPromise: <T>(value: unknown) => value is Promise<T>;
+    readonly isReactPortal: TTypeGuard<react.ReactPortal>;
+    readonly hasChildren: (value: unknown) => value is {
+        children: react.ReactNode;
+    };
+    readonly isComponentType: TTypeGuard<react.ComponentType<unknown>>;
+    readonly isForwardRef: TTypeGuard<react.ForwardRefExoticComponent<object>>;
+    readonly isValidReactNode: TTypeGuard<react.ReactNode>;
+    readonly isReactElement: TTypeGuard<react.ReactElement<unknown, string | react.JSXElementConstructor<any>>>;
+    readonly isFragment: TTypeGuard<react.ReactElement<unknown, string | react.JSXElementConstructor<any>>>;
+    readonly hasOnClick: TTypeGuard<react.ReactElement<{
+        onClick?: (e: react.MouseEvent<HTMLElement>) => void;
+    }, string | react.JSXElementConstructor<any>>>;
+    readonly isElementLike: TTypeGuard<TElementLike>;
+    readonly isElementOfType: <T extends THTMLTags>(element: unknown, allowedTypes: THTMLTags) => element is {
+        type: THTMLTags;
+        props: object;
+    };
+    readonly hasNameMetadata: (type: unknown) => type is TNamedComponent;
+    readonly isDOMPropKey: TTypeGuard<string>;
+    readonly isDOMEntry: <TElement extends react.ElementType>(entry: [PropertyKey, unknown]) => entry is [Extract<keyof react.ComponentPropsWithoutRef<TElement>, string>, unknown];
+    readonly isPropValid: (arg: string) => boolean;
+};
+
+declare const assertIsNumber: TAssert<number>;
+declare const assertIsInteger: TAssert<number>;
+declare const assertIsString: TAssert<string>;
+declare const assertIsNonEmptyString: TAssert<string>;
+declare const assertIsBoolean: TAssert<boolean>;
+declare const assertIsBigInt: TAssert<bigint>;
+declare const assertIsSymbol: TAssert<symbol>;
+declare const assertIsNull: TAssert<null>;
+declare const assertIsUndefined: TAssert<undefined>;
+declare const assertIsDefined: TAssert<NonNullable<unknown>>;
+declare const assertIsNil: TAssert<null | undefined>;
+declare const assertIsFunction: TAssert<TAnyFunction>;
+declare const assertObject: TAssert<object>;
+declare const assertIsArray: TAssert<unknown[]>;
+declare const assertIsMap: TAssert<Map<unknown, unknown>>;
+declare const assertIsSet: TAssert<Set<unknown>>;
+declare const assertIsWeakMap: TAssert<WeakMap<object, unknown>>;
+declare const assertIsWeakSet: TAssert<WeakSet<object>>;
+declare const assertIsCamelCase: TAssert<string>;
+declare const assertIsBufferLikeObject: TAssert<TBufferLikeObject>;
+declare const assertIsJSONArrayString: TAssert<TJSONArrayString>;
+declare const assertIsJSONObjectString: TAssert<TJSONObjectString>;
+declare const assertIsJsonString: TAssert<TJSONDataString>;
+declare const assertIsAbsoluteUrl: TAssert<TAbsoluteURL>;
+declare const assertIsInternalUrl: TAssert<TInternalUrl>;
+declare const assertIsRGBTuple: TAssert<TRGB>;
+declare const AssertionUtils: {
+    readonly assertValue: <T>(value: unknown, typeGuard: TTypeGuard<T>, message?: string) => asserts value is T;
+    readonly makeAssert: <T>(guard: TTypeGuard<T>, _key: string) => TAssert<T>;
+    readonly assertIsNumber: TAssert<number>;
+    readonly assertIsInteger: TAssert<number>;
+    readonly assertIsString: TAssert<string>;
+    readonly assertIsNonEmptyString: TAssert<string>;
+    readonly assertIsBoolean: TAssert<boolean>;
+    readonly assertIsBigInt: TAssert<bigint>;
+    readonly assertIsSymbol: TAssert<symbol>;
+    readonly assertIsNull: TAssert<null>;
+    readonly assertIsUndefined: TAssert<undefined>;
+    readonly assertIsDefined: TAssert<{}>;
+    readonly assertIsNil: TAssert<null | undefined>;
+    readonly assertIsFunction: TAssert<TAnyFunction>;
+    readonly assertObject: TAssert<object>;
+    readonly assertIsArray: TAssert<unknown[]>;
+    readonly assertIsMap: TAssert<Map<unknown, unknown>>;
+    readonly assertIsSet: TAssert<Set<unknown>>;
+    readonly assertIsWeakMap: TAssert<WeakMap<object, unknown>>;
+    readonly assertIsWeakSet: TAssert<WeakSet<object>>;
+    readonly assertIsCamelCase: TAssert<string>;
+    readonly assertIsBufferLikeObject: TAssert<TBufferLikeObject>;
+    readonly assertIsJSONArrayString: TAssert<TJSONArrayString>;
+    readonly assertIsJSONObjectString: TAssert<TJSONObjectString>;
+    readonly assertIsJsonString: TAssert<TJSONDataString>;
+    readonly assertIsAbsoluteUrl: TAssert<TAbsoluteURL>;
+    readonly assertIsInternalUrl: TAssert<TInternalUrl>;
+    readonly assertIsRGBTuple: TAssert<TRGB>;
+};
+
+/**
+ * ## 🔠 capitalizeString — Capitalize First Letter
+ *
+ * Converts the first character of a string to uppercase while preserving
+ * the rest of the string.
+ *
+ * This utility also preserves **TypeScript literal inference**
+ * using the built-in `Capitalize<T>` type.
+ *
+ * ---
+ *
+ * ### Example
+ *
+ * ```ts
+ * capitalizeString('hello'); // "Hello"
+ * capitalizeString('userName'); // "UserName"
+ * ```
+ *
+ * @param str - String to capitalize
+ * @returns String with first letter capitalized
+ */
+declare const capitalizeString: <S extends string>(str: S) => Capitalize<S>;
+/**
+ * ## 🐪 toCamelCase — Convert String to camelCase
+ *
+ * Converts a string from various formats (`snake_case`, `kebab-case`,
+ * space-separated, etc.) into **camelCase**.
+ *
+ * This utility:
+ * - Normalizes separators (`-`, `_`, spaces)
+ * - Converts word boundaries to camel casing
+ * - Returns an empty string if the value is invalid
+ *
+ * ---
+ *
+ * ### Example
+ *
+ * ```ts
+ * toCamelCase('hello-world'); // "helloWorld"
+ * toCamelCase('user_name'); // "userName"
+ * toCamelCase('Hello World'); // "helloWorld"
+ * ```
+ *
+ * @param value - String to transform
+ */
+declare const toCamelCase: <T extends TCamelCase<string>>(value: T | string) => TCamelCase<T | string>;
+/**
+ * ## 🧵 toKebabCase — Convert String to kebab-case
+ *
+ * Converts a string into **kebab-case**, commonly used for
+ * URLs, CSS class names, and HTML attributes.
+ *
+ * The function:
+ * - Normalizes camelCase boundaries
+ * - Splits words by separators
+ * - Joins them using `-`
+ *
+ * ---
+ *
+ * ### Example
+ *
+ * ```ts
+ * toKebabCase('helloWorld'); // "hello-world"
+ * toKebabCase('User Name'); // "user-name"
+ * toKebabCase('user_name'); // "user-name"
+ * ```
+ *
+ * @param value - String to transform
+ */
+declare const toKebabCase: <T extends string>(value: T | string) => TKebabCase<T | string>;
+/**
+ * ## 🐍 toSnakeCase — Convert String to snake_case
+ *
+ * Converts a string into **snake_case**, commonly used for
+ * database fields, environment variables, and backend APIs.
+ *
+ * The function:
+ * - Splits words by separators and camelCase boundaries
+ * - Joins them using `_`
+ *
+ * ---
+ *
+ * ### Example
+ *
+ * ```ts
+ * toSnakeCase('helloWorld'); // "hello_world"
+ * toSnakeCase('User Name'); // "user_name"
+ * toSnakeCase('user-name'); // "user_name"
+ * ```
+ *
+ * @param value - String to transform
+ */
+declare const toSnakeCase: <T extends string>(value: T | string) => TSnakeCase<T | string>;
+
+/**
+ * ## 🔑 generateKeyMap — Create a Typed Key Transformation Map
+ *
+ * Generates an object mapping original keys to transformed string values
+ * using an optional **prefix** and required **suffix**.
+ *
+ * This is useful when generating standardized property names such as
+ * getter/setter names, CSS class maps, or API field mappings.
+ *
+ * ---
+ *
+ * ### ⚙️ Behavior
+ * - Iterates through the provided `keys` array.
+ * - Builds a new string for each key using:
+ *   - Optional `prefix`
+ *   - Capitalized original key
+ *   - Required `suffix`
+ * - Returns a **fully typed mapping object** where:
+ *
+ * ```
+ * key -> transformedValue
+ * ```
+ *
+ * ---
+ *
+ * ### 📘 Example
+ *
+ * ```ts
+ * const map = generateKeyMap({
+ *   keys: ['name', 'email'] as const,
+ *   prefix: 'get',
+ *   suffix: 'Value',
+ * });
+ *
+ * // Result:
+ * // {
+ * //   name: "getNameValue",
+ * //   email: "getEmailValue"
+ * // }
+ * ```
+ *
+ * ---
+ *
+ * @typeParam K - Keys to transform
+ * @typeParam P - Optional prefix string
+ * @typeParam S - Required suffix string
+ */
+declare const generateKeyMap: <K extends string, P extends string | undefined = undefined, S extends string = string>(data: {
+    keys: readonly K[];
+    prefix?: P;
+    suffix: S;
+}) => Record<K, P extends string ? `${P}${Capitalize<K>}${S}` : `${K}${S}`>;
+/**
+ * ## 🗂️ toKeyByField — Convert Array to Keyed Object
+ *
+ * Converts an array of objects into a **record keyed by a specific field**.
+ *
+ * The specified key field becomes the **object key**, and the remaining
+ * properties are preserved as the value.
+ *
+ * This is useful for quickly creating lookup tables from API responses
+ * or normalized datasets.
+ *
+ * ---
+ *
+ * ### 📘 Example
+ *
+ * ```ts
+ * const users = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ * ];
+ *
+ * const map = toKeyByField(users, 'id');
+ *
+ * // Result:
+ * // {
+ * //   1: { name: 'Alice' },
+ * //   2: { name: 'Bob' }
+ * // }
+ * ```
+ *
+ * ---
+ *
+ * @param rows - Array of objects to transform
+ * @param keyField - Property used as the object key
+ */
+declare const toKeyByField: <RowType extends Record<Key, string | number | symbol>, Key extends keyof RowType>(rows: RowType[], keyField: Key) => Record<RowType[Key], Omit<RowType, Key>>;
+/**
+ * ## 🔠 capitalizeArray — Capitalize All Strings in an Array
+ *
+ * Transforms every string in an array so that the **first letter is capitalized**.
+ *
+ * Uses the `capitalizeString` utility internally and preserves the
+ * literal type relationship using `Capitalize<T>`.
+ *
+ * ---
+ *
+ * ### 📘 Example
+ *
+ * ```ts
+ * capitalizeArray(['name', 'email']);
+ *
+ * // Result:
+ * // ['Name', 'Email']
+ * ```
+ *
+ * ---
+ *
+ * @param arr - Array of strings to capitalize
+ */
+declare const capitalizeArray: <T extends string>(arr: readonly T[]) => Capitalize<T>[];
+/**
+ * ## 🔠 capitalizedKeys — Get Capitalized Object Keys
+ *
+ * Extracts keys from an object and returns them as an array of
+ * **capitalized strings**.
+ *
+ * Only keys that **start with a letter** are included.
+ *
+ * This is useful when generating UI labels, enum-like lists,
+ * or metadata from object shapes.
+ *
+ * ---
+ *
+ * ### 📘 Example
+ *
+ * ```ts
+ * const user = {
+ *   id: 1,
+ *   name: 'Alice',
+ * };
+ *
+ * capitalizedKeys(user);
+ *
+ * // Result:
+ * // ['Id', 'Name']
+ * ```
+ *
+ * ---
+ *
+ * @param obj - Object whose keys should be capitalized
+ */
+declare const capitalizedKeys: <T extends Record<string, unknown>>(obj: T) => Capitalize<keyof T & string>[];
+
+declare const TransformersUtils: {
+    readonly capitalizedKeys: <T extends Record<string, unknown>>(obj: T) => Capitalize<keyof T & string>[];
+    readonly capitalizeArray: <T extends string>(arr: readonly T[]) => Capitalize<T>[];
+    readonly toKeyByField: <RowType extends Record<Key, string | number | symbol>, Key extends keyof RowType>(rows: RowType[], keyField: Key) => Record<RowType[Key], Omit<RowType, Key>>;
+    readonly generateKeyMap: <K extends string, P extends string | undefined = undefined, S extends string = string>(data: {
+        keys: readonly K[];
+        prefix?: P;
+        suffix: S;
+    }) => Record<K, P extends string ? `${P}${Capitalize<K>}${S}` : `${K}${S}`>;
+    readonly toSnakeCase: <T extends string>(value: T | string) => TSnakeCase<T | string>;
+    readonly toKebabCase: <T extends string>(value: T | string) => TKebabCase<T | string>;
+    readonly toCamelCase: <T extends TCamelCase<string>>(value: T | string) => TCamelCase<T | string>;
+    readonly capitalizeString: <S extends string>(str: S) => Capitalize<S>;
+};
+
+declare function highlight(text: string, colorCode?: keyof typeof ANSI_COLOR_CODES): string;
+/**
+ * Safely serializes any value into a readable string.
+ *
+ * - Handles objects, BigInts, and circular structures gracefully.
+ * - Pretty-prints JSON for readability.
+ *
+ * @example
+ * ```ts
+ * DebugUtils.serialize({ foo: 'bar' });
+ * // => "{\n  \"foo\": \"bar\"\n}"
+ * ```
+ */
+declare const serialize: (data: unknown) => string;
+/**
+ * UTIL LOCATION: DEBUG UTILS
+ *
+ *
+ * Retrieves the caller's location (file, line, and column) from the stack trace.
+ *
+ * Useful for logging, debugging, and tracing where a function was called from.
+ *
+ * It works by inspecting `Error().stack` and extracting relevant frames.
+ *
+ * @param preferredIndex - The zero-based stack frame index to prioritize (default: 3).
+ * @param fallbackIndex - The fallback frame index if the preferred frame doesn’t exist (default: 2).
+ * @param topParent - If `true`, returns the top-most relevant stack frame in your code (skipping `node_modules`).
+ * @param stripPathPrefix - If provided, removes this prefix (e.g., your project root path) from the returned string.
+ *
+ * @returns A string describing the caller’s location, e.g. `"src/utils/core/debug.ts:42:15"`.
+ *
+ * @example
+ * ```ts
+ * import { DebugUtils } from '@/utils/core/debug';
+ *
+ * function exampleFunction() {
+ *   console.log(DebugUtils.getCallerLocation());
+ * }
+ *
+ * exampleFunction();
+ * // Example output:
+ * // "src/utils/core/debug.ts:12:5"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Get the top-most relevant frame (ignoring node_modules)
+ * console.log(DebugUtils.getCallerLocation(3, 2, true));
+ * // Example output:
+ * // "src/server/api/user.ts:88:17"
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Strip out the absolute path prefix for cleaner logs
+ * console.log(DebugUtils.getCallerLocation(3, 2, false, process.cwd()));
+ * // Example output:
+ * // "/src/services/logger.ts:54:9"
+ * ```
+ */
+declare const getCallerLocation: (options: TGetCallerLocationOptions) => string;
+/**
+ * Logs messages to the console **only in development environment** unless overridden.
+ * Supports standard log types ('log', 'warn', 'error', 'info', 'debug') as well as
+ * table logging for structured data.
+ *
+ * @remarks
+ * - If the first argument matches a log type in `LOG_TYPES`, it is treated as the type.
+ * - Table logs are automatically formatted if the items contain a `current` array of objects.
+ * - Each message is stringified if it is an object.
+ * - Optional highlighters can be applied via `logTypeHighlighters`.
+ *
+ * @param options - Configuration options for this log call
+ * @param options.enabled - Whether this log should be enabled (default: true)
+ * @param options.overrideDev - Force logging even in production (default: false)
+ * @param args - Messages to log. If the first item is a log type string, it is used as the type.
+ *
+ * @example
+ * ```ts
+ * logDev({}, 'info', 'Server started on port', 3000);
+ *
+ * logDev({ overrideDev: true }, 'error', new Error('Something failed'));
+ *
+ * logDev({}, 'table', { current: [{ key: 'task1', start: 0, end: 120 }] });
+ * ```
+ *
+ */
+declare const logDev: (options: TLogOptions, ...args: unknown[]) => void;
+
+declare class DebugUtils {
+    static readonly highlight: typeof highlight;
+    static readonly serialize: (data: unknown) => string;
+    static readonly getCallerLocation: (options: TGetCallerLocationOptions) => string;
+}
+
+/**
+ * Interprets a keyboard event and returns semantic information about the user's intent.
+ *
+ * This utility analyzes a `KeyboardEvent` and classifies it into meaningful actions
+ * such as copy, paste, clear, or typing, based on a configurable keyboard policy.
+ *
+ * It is framework-agnostic (works with native DOM or React keyboard events) and
+ * performs **no side effects**. Consumers decide how to respond to the result.
+ *
+ * ### Features
+ * - Detects copy and paste shortcuts across platforms (Mac / Windows).
+ * - Supports configurable allowed keys and clear keys.
+ * - Fully data-driven via `TKeyboardConfig`.
+ * - Pure and easily unit-testable.
+ *
+ * ### Example
+ * ```ts
+ * const action = getKeyboardAction(event, {
+ *   allowedKeys: ['tab', 'enter'],
+ *   clearKeys: ['escape'],
+ * });
+ *
+ * if (action.isPaste) {
+ *   updateWorkflow({ source: 'paste' });
+ * }
+ *
+ * if (action.shouldBlockTyping) {
+ *   event.preventDefault();
+ * }
+ * ```
+ *
+ * ### Default Behavior
+ * When no config is provided, the function uses `DEFAULT_KEYBOARD_CONFIG`,
+ * which includes standard navigation keys, copy/paste shortcuts, and
+ * backspace/delete as clear actions.
+ *
+ * @param event - The keyboard event to interpret (native or React keyboard event).
+ * @param config - Optional configuration to customize allowed keys, shortcuts, and clear behavior.
+ * @returns An object describing the interpreted keyboard action.
+ */
+declare function getKeyboardAction(event: KeyboardEvent, config?: TKeyboardConfig): TKeyboardActionResult;
+
+/**
+ * Preloads images with PRELOAD caching.
+ *
+ * This utility:
+ * - Uses `Image.decode()` if supported by the browser for faster, async decoding.
+ * - Falls back to `onload` / `onerror` events if `decode()` is not available.
+ * - Skips URLs that are already cached in the LRU cache.
+ *
+ * This is useful for preloading images in a performant way, avoiding repeated network requests
+ * and controlling memory usage with an LRU cache.
+ *
+ * @param urls - Array of image URLs to preload
+ * @returns A promise that resolves when all images have been preloaded
+ *
+ * @example
+ * ```ts
+ * import { preloadImages } from './lib/network/images';
+ *
+ * const images = [
+ *   '/images/photo1.jpg',
+ *   '/images/photo2.jpg',
+ *   '/images/photo3.jpg',
+ * ];
+ *
+ * // Preload images before rendering a gallery
+ * await preloadImages(images);
+ * console.log('All images are preloaded and cached!');
+ * ```
+ */
+declare function preloadImages(urls: string | string[], options?: {
+    fetchPriority?: HTMLImageElement['fetchPriority'];
+}): Promise<void>;
+/**
+ * Normalizes a variety of image sources into a plain string URL.
+ * @template T - The shape of the image object, defaulting to our base structure.
+ */
+declare function normalizeImageSrc<T extends TBaseImageObject>(src: string | T | {
+    default: T;
+} | null | undefined): string;
+
+declare const DomUtils: {
+    readonly getKeyboardAction: typeof getKeyboardAction;
+    readonly preloadImages: typeof preloadImages;
+    readonly normalizeImageSrc: typeof normalizeImageSrc;
+};
+
+type TWelfordState = {
+    count: number;
+    mean: number;
+    squaredDeviationSum: number;
+};
+declare class ComputationUtils {
+    private static toNum;
+    static round(value: number, decimals?: number): number;
+    /** forces a number to stay within a specific range */
+    static clamp(val: number, min: number, max: number): number;
+    static getPercentage(value: number | bigint, total: number | bigint, decimals?: number): number;
+    static computeMean(arr: (number | bigint)[]): number;
+    /**
+     * Determines if a value is a statistical outlier based on standard deviations.
+     * Useful for performance alerting (e.g., test duration spikes).
+     */
+    static isAnomaly(value: number, mean: number, stdDev: number, threshold?: number): boolean;
+    /**
+     * Generates a pass/fail ratio as a human-readable percentage.
+     * Leverages getPercentage for BigInt safety and consistent rounding.
+     */
+    static computeRatio(achieved: number | bigint, total: number | bigint, decimals?: number): number;
+    /**
+     * Incrementally updates Welford's running mean and variance.
+     *
+     * High-level:
+     * - Efficiently calculates running mean and variance without storing all samples.
+     * - Perfect for streaming data like oracle price feeds.
+     *
+     * https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+     *
+     * @param state - Previous Welford state, or undefined if this is the first sample
+     * @param newValue - The new data point to incorporate
+     * @returns Object containing:
+     *   - welford: updated state (count, mean, squaredDeviationSum)
+     *   - stdDev: current standard deviation based on updated state
+     */
+    static welfordUpdate(state: TWelfordState | undefined, newValue: number): {
+        welford: TWelfordState;
+        stdDev: number;
+    };
+    static computeDelta(current: bigint, past: bigint): {
+        netDelta: bigint;
+        absDelta: bigint;
+    };
+    static computeDelta(current: number, past: number): {
+        netDelta: number;
+        absDelta: number;
+    };
+    static computePercentageChange(current: number | bigint, past: number | bigint, scale?: bigint): number;
+}
+
+declare const hexToRGB: (hex: string) => TRGB;
+declare const validateRGB: (input: TRGB | string) => TRGB;
+declare const getLuminance: (rgb: TRGB | string) => number;
+/**
+ * ## 🌗 isLumLessThan — Check if a Color’s Luminance is Below a Threshold
+ *
+ * Determines whether the luminance of a color (in RGB array or HEX format)
+ * is less than the specified threshold. Uses `getLuminance()` internally.
+ *
+ * @param color - RGB tuple or HEX color string (e.g. `[255,255,255]` or `"#ffffff"`)
+ * @param threshold - A number between 0 and 1 representing the luminance cutoff.
+ * @returns `true` if the color’s luminance is less than the threshold.
+ *
+ * @example
+ * ```ts
+ * isLumLessThan('#000000', 0.2); // true
+ * isLumLessThan([255,255,255], 0.2); // false
+ * ```
+ */
+declare const isLumLessThan: (color: TRGB | string, threshold: number) => boolean;
+/**
+ * ## 🌑 isDarkColor — Check if a Color is Perceptually Dark
+ *
+ * Determines whether a color is "dark" based on a standard WCAG-inspired
+ * luminance threshold (0.179). Works with both HEX and RGB formats.
+ *
+ * @param color - RGB tuple or HEX color string.
+ * @returns `true` if the color is considered dark.
+ *
+ * @example
+ * ```ts
+ * isDarkColor('#000000'); // true
+ * isDarkColor('#ffffff'); // false
+ * ```
+ */
+declare const isDarkColor: (color: TRGB | string) => boolean;
+/**
+ * ## ☀️ isLumGreaterThan — Check if a Color’s Luminance Exceeds a Threshold
+ *
+ * Determines whether the luminance of a color is above the given threshold.
+ *
+ * @param color - RGB tuple or HEX color string.
+ * @param threshold - A number between 0 and 1 representing the luminance cutoff.
+ * @returns `true` if the color’s luminance is greater than the threshold.
+ *
+ * @example
+ * ```ts
+ * isLumGreaterThan('#ffffff', 0.2); // true
+ * isLumGreaterThan('#222222', 0.2); // false
+ * ```
+ */
+declare const isLumGreaterThan: (color: TRGB | string, threshold: number) => boolean;
+/**
+ * ## 🎨 contrastTextColor — Returns an Accessible Text Color Based on Background
+ *
+ * Dynamically selects a readable text color (`black` or `white`) depending on
+ * the background color’s luminance.
+ *
+ * The function can return:
+ * - **Tailwind classes** (e.g. `'text-black'` / `'text-white'`)
+ * - **CSS color values** (e.g. `'#000000'` / `'#ffffff'`)
+ *
+ * ---
+ *
+ * @param color - RGB tuple or HEX color string.
+ * @param options - Optional configuration for return format and threshold.
+ * @returns A string representing the contrasting text color (Tailwind or CSS).
+ *
+ * ---
+ *
+ * @example
+ * ```ts
+ * // Tailwind mode (default)
+ * contrastTextColor('#000000');
+ * // → 'text-white'
+ *
+ * // CSS mode
+ * contrastTextColor('#ffffff', { mode: 'css' });
+ * // → '#000000'
+ *
+ * // Custom threshold
+ * contrastTextColor([120,120,120], { threshold: 0.2 });
+ * // → 'text-white'
+ * ```
+ */
+declare const contrastTextColor: (color: TRGB | string, options?: {
+    mode?: "tailwind" | "css";
+    threshold?: number;
+}) => string;
+/**
+ * ## 🎨 hexToRGBShorthand — Convert Hex Color to RGB Array
+ *
+ * Converts a **hex color string** into an RGB array `[r, g, b]`.
+ * Supports both **3-character shorthand** (e.g., `#abc`) and **6-character hex** (e.g., `#aabbcc`).
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - Convert a user-friendly or CSS hex color into a numeric RGB array.
+ * - Handles shorthand hex and expands it automatically.
+ * - Returns `null` for invalid hex strings.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * hexToRGBShorthand('#abc');     // [170, 187, 204]
+ * hexToRGBShorthand('#aabbcc');  // [170, 187, 204]
+ * hexToRGBShorthand('invalid');  // null
+ * ```
+ *
+ * ---
+ *
+ * ### 📌 Notes
+ * - Input must be a valid 3- or 6-character hex string (case-insensitive).
+ * - Output is always a `[number, number, number]` array if valid.
+ */
+declare const hexToRGBShorthand: (hex: string) => [number, number, number] | null;
+/**
+ * ## 🎨 interpolateColor — Linear Interpolation Between Two RGB Colors
+ *
+ * Interpolates between two RGB colors based on a `factor` and returns a **CSS rgb() string**.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - Blend two colors linearly using a numeric factor between `0` and `1`.
+ * - `factor = 0` returns the `start` color.
+ * - `factor = 1` returns the `end` color.
+ * - Any value in-between returns the proportional mix.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * interpolateColor(
+ *   { r: 255, g: 0, b: 0 },
+ *   { r: 0, g: 0, b: 255 },
+ *   0.5
+ * );
+ * // → "rgb(128, 0, 128)"
+ *
+ * interpolateColor(
+ *   { r: 0, g: 255, b: 0 },
+ *   { r: 0, g: 0, b: 0 },
+ *   0.25
+ * );
+ * // → "rgb(0, 191, 0)"
+ * ```
+ *
+ * ---
+ *
+ * ### 📌 Notes
+ * - `start` and `end` colors must have `r`, `g`, `b` values as numbers.
+ * - `factor` should ideally be in `[0, 1]`, but values outside will extrapolate.
+ * - Returns a **valid CSS rgb() string** ready to use in style properties.
+ */
+declare const interpolateColor: (start: {
+    r: number;
+    g: number;
+    b: number;
+}, end: {
+    r: number;
+    g: number;
+    b: number;
+}, factor: number) => TCssRGB;
+/**
+ * Converts a hex color string to an HSL (Hue, Saturation, Lightness) object.
+ *
+ * @param hex - A hexadecimal color string (e.g., "#ff0000" or "ff0000")
+ * @returns An object with:
+ *   - h: hue in degrees [0, 360)
+ *   - s: saturation [0, 1]
+ *   - l: lightness [0, 1]
+ *
+ * @example
+ * hexToHSL("#ff0000") // { h: 0, s: 1, l: 0.5 }
+ */
+declare function hexToHSL(hex: string): {
+    h: number;
+    s: number;
+    l: number;
+};
+/**
+ * Converts a hexadecimal color string to a normalized RGB tuple.
+ *
+ * This function takes a standard hex color (like `#ff0000` or `ff0000`) and
+ * converts it to an RGB representation where each channel is a decimal number
+ * between 0 and 1 instead of 0–255. This format is commonly used in graphics
+ * and WebGL contexts (like Three.js or shaders) that expect normalized RGB values.
+ *
+ * @param hex - A hexadecimal color string, either in 3-digit shorthand (`#f00`)
+ *              or 6-digit full form (`#ff0000`). The leading `#` is optional.
+ *
+ * @returns A tuple `[r, g, b]` where each component is a number between 0 and 1:
+ *          - `r` = red channel normalized (0–1)
+ *          - `g` = green channel normalized (0–1)
+ *          - `b` = blue channel normalized (0–1)
+ *
+ * @example
+ * hexToNormalizedRGB("#ff0000"); // [1, 0, 0]  → pure red
+ * hexToNormalizedRGB("00ff00");  // [0, 1, 0]  → pure green
+ * hexToNormalizedRGB("#0000ff"); // [0, 0, 1]  → pure blue
+ */
+declare const hexToNormalizedRGB: (hex: string) => [number, number, number];
+
+declare const ColorUtils: {
+    readonly hexToNormalizedRGB: (hex: string) => [number, number, number];
+    readonly hexToHSL: typeof hexToHSL;
+    readonly interpolateColor: (start: {
+        r: number;
+        g: number;
+        b: number;
+    }, end: {
+        r: number;
+        g: number;
+        b: number;
+    }, factor: number) => TCssRGB;
+    readonly hexToRGBShorthand: (hex: string) => [number, number, number] | null;
+    readonly contrastTextColor: (color: TRGB | string, options?: {
+        mode?: "tailwind" | "css";
+        threshold?: number;
+    }) => string;
+    readonly isLumGreaterThan: (color: TRGB | string, threshold: number) => boolean;
+    readonly isDarkColor: (color: TRGB | string) => boolean;
+    readonly isLumLessThan: (color: TRGB | string, threshold: number) => boolean;
+    readonly getLuminance: (rgb: TRGB | string) => number;
+    readonly validateRGB: (input: TRGB | string) => TRGB;
+    readonly hexToRGB: (hex: string) => TRGB;
+};
+
+/**
+ * Normalize various URL inputs to a string.
+ *
+ * @param href - The input URL, which can be a string, URL instance, or object with pathname/query/hash.
+ * @returns A normalized string URL.
+ *
+ * @example
+ * LinkUtils.normalizeUrl('https://example.com/path?query=1#hash');
+ * // 'https://example.com/path?query=1#hash'
+ *
+ * @example
+ * LinkUtils.normalizeUrl({ pathname: '/path', query: { q: '1' }, hash: '#section' });
+ * // '/path?q=1#section'
+ */
+declare function normalizeUrl(href?: string | URL | TGenericUrlObject | null): string;
+/**
+ * ## 🧩 extractRelativePath — Extracts Relative Paths
+ *
+ * Extracts the relative path from an internal URL or absolute URL pointing
+ * to the same origin. Ensures that the returned path always starts with `/`.
+ *
+ * ---
+ *
+ * ### ⚙️ Core Purpose
+ * - 🔹 Converts internal absolute URLs to relative paths.
+ * - 🔹 Preserves already relative paths.
+ * - 🔹 Safely handles invalid or external URLs by returning `/`.
+ *
+ * ---
+ *
+ * ### 📘 Example Usage
+ * ```ts
+ * LinkUtils.extractRelativePath('/about');
+ * // '/about'
+ *
+ * LinkUtils.extractRelativePath('https://example.com/about?query=1');
+ * // '/about'
+ *
+ * LinkUtils.extractRelativePath('https://external.com/page');
+ * // '/'
+ * ```
+ *
+ * ---
+ *
+ * @param url - The input URL string or unknown value.
+ * @returns A string representing the relative path, always starting with `/`.
+ */
+declare const extractRelativePath: (url?: unknown) => string;
+/**
+ * Removes the hash fragment from a URL string while preserving path and query.
+ */
+declare const stripHash: (url?: string) => string;
+declare const handleInternalHashScroll: ({ event, href, behavior, block, }: THashScrollOptions) => boolean;
+
+declare class LinkUtils {
+    static readonly normalize: typeof normalizeUrl;
+    static readonly extractRelativePath: (url?: unknown) => string;
+    static readonly stripHash: (url?: string) => string;
+    static readonly handleHashScroll: ({ event, href, behavior, block, }: THashScrollOptions) => boolean;
+}
+
+export { ANSI_COLOR_CODES, ArrayUtils, AssertionUtils, type Branded, CollectionTypeGuards, ColorUtils, ComputationUtils, CoreTypeGuards, DEFAULT_KEYBOARD_CONFIG, DebugUtils, DomUtils, FormatTypeGuards, HTML_TAGS, LOG_TYPES, LinkUtils, type ModifierKey, ObjectUtils, REGEX_CONSTANTS, ReactTypeGuards, RenamedArrayMethods, RenamedObjectMethods, SAFE_HTML_TAGS, type TAbsoluteURL, type TAnyFunction, type TArrayItems, type TArrayLengthMutationKeys, type TAssert, type TBaseImageObject, type TBufferLikeObject, type TCamelCase, type TCssRGB, type TElementLike, type TFixedLengthArray, type TGenericUrlObject, type TGetCallerLocationOptions, type THTMLTags, type THashScrollOptions, type THexByteString, type THighlighterMap, type TInternalUrl, type TJSONArrayString, type TJSONDataString, type TJSONObjectString, type TKebabCase, type TKeyboardActionResult, type TKeyboardConfig, type TLogOptions, type TLogType, type TNamedComponent, type TProcessedTableItem, type TPropCategories, type TPropMap, type TRGB, type TShortcutDefinition, type TSnakeCase, type TStaticMethods, type TTableItem, type TTypeGuard, TransformersUtils, VALID_DOM_PROPS, VALID_DOM_TESTING_KEYS, arrayFilter, arrayFilterNonNullable, arrayFlat, arrayFlatMap, arrayForEach, arrayIncludes, arrayMap, arrayReduce, assertIsAbsoluteUrl, assertIsArray, assertIsBigInt, assertIsBoolean, assertIsBufferLikeObject, assertIsCamelCase, assertIsDefined, assertIsFunction, assertIsInteger, assertIsInternalUrl, assertIsJSONArrayString, assertIsJSONObjectString, assertIsJsonString, assertIsMap, assertIsNil, assertIsNonEmptyString, assertIsNull, assertIsNumber, assertIsRGBTuple, assertIsSet, assertIsString, assertIsSymbol, assertIsUndefined, assertIsWeakMap, assertIsWeakSet, assertObject, capitalizeArray, capitalizeString, capitalizedKeys, contrastTextColor, extractRelativePath, generateKeyMap, getCallerLocation, getKeyboardAction, getLuminance, handleInternalHashScroll, hasChildren, hasDefinedKeys, hasNameMetadata, hasOnClick, hexToHSL, hexToNormalizedRGB, hexToRGB, hexToRGBShorthand, highlight, interpolateColor, isAbsoluteUrl, isArray, isArrayOf, isBigInt, isBoolean, isBufferLikeObject, isCamelCase, isComponentType, isDOMEntry, isDOMPropKey, isDarkColor, isDefined, isElementLike, isElementOfType, isEmail, isForwardRef, isFragment, isFunction, isHTMLString, isHexByteString, isInArray, isInstanceOf, isInteger, isInternalUrl, isJSONArrayString, isJSONObjectString, isJsonString, isKebabCase, isKeyInObject, isKeyOfArray, isKeyOfObject, isLumGreaterThan, isLumLessThan, isMap, isNil, isNonEmptyString, isNull, isNumber, isObject, isPhoneNumber, isPrimitive, isPromise, isPropValid, isRGBTuple, isReactElement, isReactPortal, isRecordOf, isRef, isRefObject, isSet, isSnakeCase, isString, isSymbol, isUndefined, isValidReactNode, isWeakMap, isWeakSet, logDev, normalizeImageSrc, normalizeUrl, objectEntries, objectFromEntries, objectGet, objectHas, objectKeys, objectSet, objectValues, preloadImages, serialize, stripHash, toCamelCase, toKebabCase, toKeyByField, toSnakeCase, validateRGB };