/**
 * Color design tokens for BeatUI.
 *
 * Defines the complete color system including base color shades, semantic color
 * mappings, background/text/border/interactive theme colors, and CSS variable
 * generation utilities. Colors follow a shade scale from 50 (lightest) to 950
 * (darkest) and support light/dark theme modes.
 *
 * @module
 */
import { colors } from './base-colors';
/**
 * Union type of all available base color names derived from the color palette.
 *
 * @example
 * ```ts
 * const color: ColorName = 'blue'
 * ```
 */
export type ColorName = keyof typeof colors;
/**
 * Union type representing the available shade levels in the color scale.
 * Ranges from 50 (lightest) to 950 (darkest).
 */
export type ColorShade = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
/**
 * Array of all available color shade values, ordered from lightest to darkest.
 *
 * @example
 * ```ts
 * colorShades.forEach(shade => {
 *   console.log(`--color-blue-${shade}`)
 * })
 * ```
 */
export declare const colorShades: ColorShade[];
/**
 * Union type of semantic color role names used throughout the theme system.
 * Semantic colors map to base color names and can be overridden per-theme.
 */
export type SemanticColorName = 'primary' | 'secondary' | 'base' | 'success' | 'warning' | 'danger' | 'info';
/**
 * Union type of all theme-aware color names, including base colors,
 * semantic colors, and the special 'black' and 'white' values.
 */
export type ThemeColorName = ColorName | SemanticColorName | 'black' | 'white';
/**
 * Tuple of all semantic color names, used for iteration and validation.
 */
export declare const semanticColorNames: readonly ["primary", "secondary", "base", "success", "warning", "danger", "info"];
/**
 * Array of all available theme color names, combining semantic colors,
 * base palette colors, and the special 'black' and 'white' values.
 *
 * @example
 * ```ts
 * themeColorNames.forEach(name => {
 *   console.log(name) // 'primary', 'blue', 'red', 'black', etc.
 * })
 * ```
 */
export declare const themeColorNames: ThemeColorName[];
/**
 * Default mapping from semantic color names to base color names.
 *
 * @default
 * ```
 * primary   -> 'blue'
 * secondary -> 'gray'
 * base      -> 'gray'
 * success   -> 'green'
 * warning   -> 'amber'
 * danger    -> 'red'
 * info      -> 'blue'
 * ```
 */
export declare const semanticColors: Record<SemanticColorName, ColorName>;
/**
 * Partial record for overriding default semantic-to-base color mappings.
 *
 * @example
 * ```ts
 * const overrides: SemanticColorOverrides = { primary: 'indigo', danger: 'rose' }
 * ```
 */
export type SemanticColorOverrides = Partial<Record<SemanticColorName, ThemeColorName>>;
/**
 * Resolves the full semantic color map by merging defaults with any provided overrides.
 *
 * @param overrides - Optional partial overrides for semantic color mappings
 * @returns A complete mapping of semantic color names to their resolved color names
 *
 * @example
 * ```ts
 * const map = resolveSemanticColorMap({ primary: 'indigo' })
 * // map.primary === 'indigo', map.secondary === 'gray', etc.
 * ```
 */
export declare function resolveSemanticColorMap(overrides?: SemanticColorOverrides): {
    base: ThemeColorName;
    primary: ThemeColorName;
    secondary: ThemeColorName;
    success: ThemeColorName;
    warning: ThemeColorName;
    danger: ThemeColorName;
    info: ThemeColorName;
};
/**
 * Union type of background color role names used in the theme system.
 * Each role represents a different surface elevation level.
 */
export type BackgroundColorName = 'background' | 'surface' | 'subtle' | 'elevated' | 'raised' | 'overlay';
/**
 * Background color definitions for light and dark theme modes.
 * Each entry maps a background role to a `[ThemeColorName, ColorShade]` tuple.
 */
export declare const bgColors: {
    light: Record<BackgroundColorName, [ThemeColorName, ColorShade]>;
    dark: Record<BackgroundColorName, [ThemeColorName, ColorShade]>;
};
/**
 * Union type of text color role names used in the theme system.
 */
export type TextColorName = 'normal' | 'muted' | 'inverted';
/**
 * Text color definitions for light and dark theme modes.
 * Each entry maps a text role to a `[ThemeColorName, ColorShade]` tuple.
 */
export declare const textColors: {
    light: Record<TextColorName, [ThemeColorName, ColorShade]>;
    dark: Record<TextColorName, [ThemeColorName, ColorShade]>;
};
/**
 * Union type of border color role names used in the theme system.
 */
export type BorderColorName = 'subtle' | 'muted' | 'border' | 'divider' | 'input' | 'strong' | 'inverted';
/**
 * Border color definitions for light and dark theme modes.
 * Each entry maps a border role to a `[ThemeColorName, ColorShade]` tuple.
 */
export declare const borderColors: {
    light: Record<BorderColorName, [ThemeColorName, ColorShade]>;
    dark: Record<BorderColorName, [ThemeColorName, ColorShade]>;
};
/**
 * Union type of interactive color role names for focus, hover, and active states.
 */
export type InteractiveColorName = 'focus' | 'hover' | 'active';
/**
 * Interactive color definitions for light and dark theme modes.
 * Used for focus rings, hover backgrounds, and active state backgrounds.
 */
export declare const interactiveColors: {
    light: Record<InteractiveColorName, [ThemeColorName, ColorShade]>;
    dark: Record<InteractiveColorName, [ThemeColorName, ColorShade]>;
};
/**
 * Resolves a theme color name to its underlying base color name.
 * If the color is a semantic name (e.g., 'primary'), it is resolved through the
 * semantic color map (with optional overrides). Otherwise, the color name is returned as-is.
 *
 * @param color - The theme color name to normalize
 * @param overrides - Optional semantic color overrides
 * @returns The resolved base color name
 *
 * @example
 * ```ts
 * normalizeColorName('primary') // 'blue'
 * normalizeColorName('primary', { primary: 'indigo' }) // 'indigo'
 * normalizeColorName('red') // 'red'
 * ```
 */
export declare function normalizeColorName(color: ThemeColorName, overrides?: SemanticColorOverrides): ThemeColorName;
/**
 * Returns the CSS custom property name for a given color and shade.
 *
 * @param color - The theme color name
 * @param shade - The shade level
 * @returns The CSS variable name (e.g., `'--color-blue-500'`, `'--color-white'`)
 *
 * @example
 * ```ts
 * getColorVarName('blue', 500) // '--color-blue-500'
 * getColorVarName('white', 500) // '--color-white'
 * ```
 */
export declare function getColorVarName(color: ThemeColorName, shade: ColorShade): `--color-${ThemeColorName}-${ColorShade}` | '--color-white' | '--color-black';
/**
 * Returns a CSS `var()` expression referencing the color custom property.
 *
 * @param color - The theme color name
 * @param shade - The shade level
 * @returns A CSS `var()` string (e.g., `'var(--color-blue-500)'`)
 *
 * @example
 * ```ts
 * getColorVar('blue', 500) // 'var(--color-blue-500)'
 * ```
 */
export declare function getColorVar(color: ThemeColorName, shade: ColorShade): string;
/**
 * Union type of background variant styles used for component backgrounds.
 * Controls the shade intensity applied to colored backgrounds.
 */
export type BackgroundVariant = 'solid' | 'soft' | 'light' | 'lighter';
/**
 * Configuration object for background utility CSS generation.
 * Contains special color overrides, standard variant shade mappings for
 * light/dark modes, and color-specific overrides for 'white', 'black',
 * and 'transparent'.
 */
export declare const backgroundConfig: {
    readonly special: {
        readonly inherit: {
            readonly backgroundColor: "inherit";
            readonly color: "inherit";
        };
        readonly white: {
            readonly backgroundColor: "var(--color-white)";
            readonly color: "var(--color-base-900)";
        };
        readonly black: {
            readonly backgroundColor: "black";
            readonly color: "var(--color-white)";
        };
        readonly transparent: {
            readonly backgroundColor: "transparent";
            readonly color: "inherit";
        };
    };
    readonly variants: {
        readonly solid: {
            readonly light: {
                readonly bgShade: 600;
                readonly textColor: "var(--color-white)";
            };
            readonly dark: {
                readonly bgShade: 400;
                readonly textColor: "var(--color-black)";
            };
        };
        readonly soft: {
            readonly light: {
                readonly bgShade: 300;
                readonly textColor: "var(--text-normal-light)";
            };
            readonly dark: {
                readonly bgShade: 700;
                readonly textColor: "var(--text-normal-dark)";
            };
        };
        readonly light: {
            readonly light: {
                readonly bgShade: 100;
                readonly textColor: "var(--text-normal-light)";
            };
            readonly dark: {
                readonly bgShade: 800;
                readonly textColor: "var(--text-normal-dark)";
            };
        };
        readonly lighter: {
            readonly light: {
                readonly bgShade: 100;
                readonly textColor: "var(--text-normal-light)";
            };
            readonly dark: {
                readonly bgShade: 900;
                readonly textColor: "var(--text-normal-dark)";
            };
        };
    };
    readonly overrides: {
        readonly white: {
            readonly light: {
                readonly backgroundColor: "var(--color-white)";
                readonly color: "var(--color-base-900)";
            };
            readonly dark: {
                readonly backgroundColor: "var(--color-black)";
                readonly color: "var(--color-base-100)";
            };
        };
        readonly black: {
            readonly light: {
                readonly backgroundColor: "black";
                readonly color: "var(--color-white)";
            };
            readonly dark: {
                readonly backgroundColor: "black";
                readonly color: "var(--color-white)";
            };
        };
        readonly transparent: {
            readonly light: {
                readonly backgroundColor: "transparent";
                readonly color: "inherit";
            };
            readonly dark: {
                readonly backgroundColor: "transparent";
                readonly color: "inherit";
            };
        };
    };
};
/**
 * Generates CSS custom property declarations for all core (base) color tokens.
 * Includes `--color-white`, `--color-black`, `--color-inherit`, and all
 * base palette colors at every shade level.
 *
 * @returns A record mapping CSS variable names to their values
 *
 * @example
 * ```ts
 * const vars = generateCoreColorVariables()
 * // vars['--color-blue-500'] === 'oklch(0.623 0.214 259.815)'
 * // vars['--color-white'] === 'white'
 * ```
 */
export declare function generateCoreColorVariables(): Record<string, string>;
/**
 * Generates CSS custom property declarations for semantic colors, background
 * colors, text colors, border colors, and interactive colors. Semantic colors
 * reference base color variables so themes can be changed by swapping the
 * semantic mapping.
 *
 * @param overrides - Optional overrides for semantic color mappings
 * @returns A record mapping CSS variable names to their values
 *
 * @example
 * ```ts
 * const vars = generateSemanticColorVariables({ primary: 'indigo' })
 * // vars['--color-primary-500'] === 'var(--color-indigo-500)'
 * ```
 */
export declare function generateSemanticColorVariables(overrides?: SemanticColorOverrides): Record<string, string>;
/**
 * Generates the complete set of CSS custom property declarations for all color tokens,
 * combining both core color variables and semantic color variables.
 *
 * @returns A record mapping all color CSS variable names to their values
 *
 * @example
 * ```ts
 * const vars = generateColorVariables()
 * // Contains both base colors and semantic mappings
 * ```
 */
export declare function generateColorVariables(): Record<string, string>;
