@aurora-ds/theme 1.5.0 → 2.0.0

package/dist/index.d.ts

@@ -23,69 +23,45 @@ type BaseBreakpoints = {
 };
 
 /**
- * Base color tokens following modern design system semantics
+ * Base color tokens following modern design system semantics - V2
  */
 type BaseColors = {
+    background: string;
+    surface: string;
+    surfaceHover: string;
+    surfaceActive: string;
+    text: string;
+    textSecondary: string;
+    textTertiary: string;
     primary: string;
-    onPrimary: string;
     primaryHover: string;
     primaryActive: string;
     primarySubtle: string;
     primaryDisabled: string;
+    onPrimary: string;
     secondary: string;
-    onSecondary: string;
     secondaryHover: string;
     secondaryActive: string;
     secondarySubtle: string;
     secondaryDisabled: string;
-    accent: string;
-    onAccent: string;
-    accentHover: string;
-    accentActive: string;
-    accentSubtle: string;
-    tertiary: string;
-    onTertiary: string;
-    tertiaryHover: string;
-    tertiaryActive: string;
-    tertiarySubtle: string;
-    tertiaryDisabled: string;
-    background: string;
-    surface: string;
-    surfaceHover: string;
-    surfaceActive: string;
-    elevated: string;
-    overlay: string;
-    text: string;
-    textSecondary: string;
-    textTertiary: string;
-    textInverse: string;
+    onSecondary: string;
     border: string;
-    borderHover: string;
-    borderFocus: string;
-    borderSubtle: string;
+    disabled: string;
+    disabledText: string;
     success: string;
-    onSuccess: string;
-    successHover: string;
     successSubtle: string;
     warning: string;
-    onWarning: string;
-    warningHover: string;
     warningSubtle: string;
     error: string;
-    onError: string;
     errorHover: string;
     errorSubtle: string;
+    onError: string;
     info: string;
-    onInfo: string;
-    infoHover: string;
     infoSubtle: string;
     link: string;
     linkHover: string;
     linkActive: string;
-    linkVisited: string;
-    focus: string;
-    disabled: string;
-    disabledText: string;
+    linkDisabled: string;
 };
 
 /**
@@ -262,6 +238,94 @@ type DeepPartial<T> = {
  * Type for theme overrides
  */
 type ThemeOverride<T extends Theme = Theme> = DeepPartial<T>;
+/**
+ * Base structure for custom themes with user-defined color tokens
+ * Use this when you want to completely replace the default color tokens
+ * with your own semantic tokens
+ */
+type CustomThemeBase<TColors extends Record<string, string>> = {
+    colors: TColors;
+    spacing: BaseSpacing;
+    radius: BaseRadius;
+    shadows: BaseShadows;
+    fontSize: BaseFontSize;
+    fontWeight: BaseFontWeight;
+    lineHeight: BaseLineHeight;
+    zIndex: BaseZIndex;
+    transition: BaseTransition;
+    opacity: BaseOpacity;
+    breakpoints: BaseBreakpoints;
+};
+/**
+ * Fully customizable theme where ALL token categories can be replaced
+ *
+ * @example
+ * ```ts
+ * // Define your own color tokens
+ * type MyColors = {
+ *     brand: string
+ *     brandHover: string
+ *     surface: string
+ *     textPrimary: string
+ *     textSecondary: string
+ * }
+ *
+ * // Create your theme type
+ * type MyTheme = CustomTheme<MyColors>
+ *
+ * // Use with createCustomTheme()
+ * const myTheme = createCustomTheme<MyColors>({
+ *     colors: {
+ *         brand: '#007bff',
+ *         brandHover: '#0056b3',
+ *         surface: '#ffffff',
+ *         textPrimary: '#212529',
+ *         textSecondary: '#6c757d',
+ *     },
+ *     // ... other tokens use defaults or custom
+ * })
+ * ```
+ */
+type CustomTheme<TColors extends Record<string, string> = Record<string, string>, TSpacing extends Record<string, string> = BaseSpacing, TRadius extends Record<string, string> = BaseRadius, TShadows extends Record<string, string> = BaseShadows, TFontSize extends Record<string, string> = BaseFontSize, TFontWeight extends Record<string, number> = BaseFontWeight, TLineHeight extends Record<string, number> = BaseLineHeight, TZIndex extends Record<string, number> = BaseZIndex, TTransition extends Record<string, string> = BaseTransition, TOpacity extends Record<string, number> = BaseOpacity, TBreakpoints extends Record<string, string> = BaseBreakpoints> = {
+    colors: TColors;
+    spacing: TSpacing;
+    radius: TRadius;
+    shadows: TShadows;
+    fontSize: TFontSize;
+    fontWeight: TFontWeight;
+    lineHeight: TLineHeight;
+    zIndex: TZIndex;
+    transition: TTransition;
+    opacity: TOpacity;
+    breakpoints: TBreakpoints;
+};
+/**
+ * Options for theme creation
+ */
+type CreateThemeOptions = {
+    /**
+     * How to handle the merge of overrides with the base theme
+     * - 'merge': Deep merge overrides into base (default, preserves base tokens)
+     * - 'replace': Replace entire categories when specified in overrides
+     */
+    mode?: 'merge' | 'replace';
+};
+/**
+ * Options for custom theme creation
+ */
+type CreateCustomThemeOptions<T> = {
+    /**
+     * Use defaults from the standard theme for non-color tokens
+     * If false, you must provide all tokens
+     * @default true
+     */
+    useDefaults?: boolean;
+    /**
+     * Partial overrides for non-color tokens
+     * Only used when useDefaults is true
+     */
+    overrides?: Partial<Omit<T, 'colors'>>;
+};
 
 /**
  * Color scale type - 12 shades from 25 to 950
@@ -291,11 +355,6 @@ type ColorName = 'gray' | 'slate' | 'stone' | 'red' | 'orange' | 'amber' | 'yell
  */
 type ColorShade = keyof ColorScale;
 
-/**
- * Available palette preset names
- */
-type PaletteName = 'indigo' | 'blue' | 'rose' | 'emerald' | 'teal' | 'violet' | 'amber' | 'cyan' | 'slate' | 'gray';
-
 type ThemeProviderProps<T extends Theme = Theme> = {
     theme: T;
     children?: ReactNode;
@@ -335,56 +394,6 @@ declare const ThemeProvider: <T extends Theme>({ theme, children }: ThemeProvide
  */
 declare const useTheme: <T extends Theme = Theme>() => T;
 
-/**
- * Create a theme by merging a base theme with overrides
- *
- * @example
- * ```ts
- * const myTheme = createTheme(defaultTheme, {
- *     colors: {
- *         primary: '#ff0000',
- *         // Only override what you need
- *     },
- *     spacing: {
- *         md: '1.5rem',
- *     },
- * })
- * ```
- */
-declare const createTheme: <T extends Theme>(baseTheme: T, overrides: DeepPartial<T>) => T;
-/**
- * Merge multiple theme overrides into one
- * Later overrides take precedence
- *
- * @example
- * ```ts
- * const theme = mergeThemes(
- *     baseTheme,
- *     brandOverrides,
- *     darkModeOverrides,
- *     userPreferences
- * )
- * ```
- */
-declare const mergeThemes: <T extends Theme>(baseTheme: T, ...overrides: DeepPartial<T>[]) => T;
-/**
- * Create a theme extension factory
- * Useful for creating theme variants (dark mode, high contrast, etc.)
- *
- * @example
- * ```ts
- * const createDarkVariant = createThemeVariant({
- *     colors: {
- *         background: '#1a1a1a',
- *         text: '#ffffff',
- *     },
- * })
- *
- * const darkTheme = createDarkVariant(lightTheme)
- * ```
- */
-declare const createThemeVariant: <T extends Theme>(variantOverrides: DeepPartial<T>) => (baseTheme: T) => T;
-
 /**
  * Default spacing scale
  */
@@ -426,68 +435,146 @@ declare const defaultOpacity: Theme['opacity'];
  */
 declare const defaultBreakpoints: Theme['breakpoints'];
 /**
- * Default colors (using indigo palette)
+ * Complete default theme V2
  */
-declare const defaultColors: BaseColors;
+declare const defaultTheme: Theme;
+
 /**
- * Default dark colors (using indigo palette)
+ * Create a theme by merging a base theme with overrides
+ *
+ * @param baseTheme - The base theme to extend
+ * @param overrides - Partial overrides to apply
+ * @param options - Optional configuration
+ * @param options.mode - 'merge' (default) deep merges, 'replace' replaces entire categories
+ *
+ * @example
+ * ```ts
+ * // Default behavior: deep merge (extends existing tokens)
+ * const myTheme = createTheme(defaultTheme, {
+ *     colors: {
+ *         primary: '#ff0000',
+ *         // Other color tokens from defaultTheme are preserved
+ *     },
+ * })
+ *
+ * // Replace mode: completely replace categories
+ * const myTheme = createTheme(defaultTheme, {
+ *     colors: {
+ *         // This becomes the ENTIRE colors object
+ *         brand: '#ff0000',
+ *         surface: '#ffffff',
+ *         text: '#000000',
+ *     },
+ * }, { mode: 'replace' })
+ * ```
  */
-declare const defaultDarkColors: BaseColors;
+declare const createTheme: <T extends Theme>(baseTheme: T, overrides: DeepPartial<T>, options?: CreateThemeOptions) => T;
 /**
- * Complete default light theme
+ * Merge multiple theme overrides into one
+ * Later overrides take precedence
+ *
+ * @example
+ * ```ts
+ * const theme = mergeThemes(
+ *     baseTheme,
+ *     brandOverrides,
+ *     darkModeOverrides,
+ *     userPreferences
+ * )
+ * ```
  */
-declare const defaultTheme: Theme;
+declare const mergeThemes: <T extends Theme>(baseTheme: T, ...overrides: DeepPartial<T>[]) => T;
 /**
- * Complete default dark theme
+ * Create a theme extension factory
+ * Useful for creating theme variants (dark mode, high contrast, etc.)
+ *
+ * @example
+ * ```ts
+ * const createDarkVariant = createThemeVariant({
+ *     colors: {
+ *         background: '#1a1a1a',
+ *         text: '#ffffff',
+ *     },
+ * })
+ *
+ * const darkTheme = createDarkVariant(lightTheme)
+ * ```
  */
-declare const defaultDarkTheme: Theme;
-
-declare const gray: ColorScale;
-
-declare const slate: ColorScale;
-
-declare const stone: ColorScale;
-
-declare const red: ColorScale;
-
-declare const orange: ColorScale;
-
-declare const amber: ColorScale;
-
-declare const yellow: ColorScale;
-
-declare const lime: ColorScale;
-
-declare const green: ColorScale;
-
-declare const emerald: ColorScale;
-
-declare const teal: ColorScale;
-
-declare const cyan: ColorScale;
-
-declare const sky: ColorScale;
-
-declare const blue: ColorScale;
-
-declare const indigo: ColorScale;
-
-declare const violet: ColorScale;
-
-declare const purple: ColorScale;
-
-declare const fuchsia: ColorScale;
-
-declare const pink: ColorScale;
-
-declare const rose: ColorScale;
+declare const createThemeVariant: <T extends Theme>(variantOverrides: DeepPartial<T>) => (baseTheme: T) => T;
+/**
+ * Create a fully custom theme with your own color tokens
+ * This allows you to define a completely different color token structure
+ * without being constrained by BaseColors
+ *
+ * @param config - Full theme configuration with custom colors
+ *
+ * @example
+ * ```ts
+ * // Define your custom color tokens
+ * type MyBrandColors = {
+ *     brand: string
+ *     brandHover: string
+ *     brandActive: string
+ *     surface: string
+ *     surfaceElevated: string
+ *     textPrimary: string
+ *     textSecondary: string
+ *     border: string
+ * }
+ *
+ * // Create a theme with ONLY your color tokens
+ * const myTheme = createCustomTheme<MyBrandColors>({
+ *     colors: {
+ *         brand: '#007bff',
+ *         brandHover: '#0056b3',
+ *         brandActive: '#004085',
+ *         surface: '#ffffff',
+ *         surfaceElevated: '#f8f9fa',
+ *         textPrimary: '#212529',
+ *         textSecondary: '#6c757d',
+ *         border: '#dee2e6',
+ *     },
+ *     // Uses defaults for other tokens, or provide your own:
+ *     // spacing: { ... },
+ *     // radius: { ... },
+ * })
+ *
+ * // TypeScript knows your theme has only YOUR color tokens:
+ * myTheme.colors.brand      // ✅ OK
+ * myTheme.colors.primary    // ❌ Error - doesn't exist
+ * ```
+ */
+declare const createCustomTheme: <TColors extends Record<string, string>, TSpacing extends Record<string, string> = typeof defaultSpacing, TRadius extends Record<string, string> = typeof defaultRadius, TShadows extends Record<string, string> = typeof defaultShadows, TFontSize extends Record<string, string> = typeof defaultFontSize, TFontWeight extends Record<string, number> = typeof defaultFontWeight, TLineHeight extends Record<string, number> = typeof defaultLineHeight, TZIndex extends Record<string, number> = typeof defaultZIndex, TTransition extends Record<string, string> = typeof defaultTransition, TOpacity extends Record<string, number> = typeof defaultOpacity, TBreakpoints extends Record<string, string> = typeof defaultBreakpoints>(config: {
+    colors: TColors;
+    spacing?: TSpacing;
+    radius?: TRadius;
+    shadows?: TShadows;
+    fontSize?: TFontSize;
+    fontWeight?: TFontWeight;
+    lineHeight?: TLineHeight;
+    zIndex?: TZIndex;
+    transition?: TTransition;
+    opacity?: TOpacity;
+    breakpoints?: TBreakpoints;
+}) => CustomTheme<TColors, TSpacing, TRadius, TShadows, TFontSize, TFontWeight, TLineHeight, TZIndex, TTransition, TOpacity, TBreakpoints>;
 
-declare const white = "#ffffff";
-declare const black = "#000000";
-declare const transparent = "transparent";
-declare const current = "currentColor";
+/**
+ * Color Scales - Modern color palettes with shades from 25 to 950
+ *
+ * Scales are only accessible via the colors object to maintain consistency
+ *
+ * @example
+ * ```ts
+ * import { colors } from '@aurora-ui/theme'
+ *
+ * colors.indigo[500]  // '#6366f1'
+ * colors.emerald[400] // '#34d399'
+ * colors.gray[900]    // '#18181b'
+ * ```
+ */
 /**
  * All color scales organized by name
+ * All scales and special values are only accessible via this object
  */
 declare const colors: {
     readonly gray: ColorScale;
@@ -516,171 +603,11 @@ declare const colors: {
     readonly current: "currentColor";
 };
 
-type ColorPalette$9 = Theme['colors'];
-/**
- * Indigo light palette - Modern, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const indigoLight: ColorPalette$9;
-/**
- * Indigo dark palette - Modern, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const indigoDark: ColorPalette$9;
-
-type ColorPalette$8 = Theme['colors'];
-/**
- * Blue light palette - Classic, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const blueLight: ColorPalette$8;
-/**
- * Blue dark palette - Classic, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const blueDark: ColorPalette$8;
-
-type ColorPalette$7 = Theme['colors'];
-/**
- * Rose light palette - Elegant, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const roseLight: ColorPalette$7;
-/**
- * Rose dark palette - Elegant, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const roseDark: ColorPalette$7;
-
-type ColorPalette$6 = Theme['colors'];
-/**
- * Emerald light palette - Fresh, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const emeraldLight: ColorPalette$6;
-/**
- * Emerald dark palette - Fresh, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const emeraldDark: ColorPalette$6;
-
-type ColorPalette$5 = Theme['colors'];
-/**
- * Teal light palette - Cool, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const tealLight: ColorPalette$5;
-/**
- * Teal dark palette - Cool, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const tealDark: ColorPalette$5;
-
-type ColorPalette$4 = Theme['colors'];
-/**
- * Violet light palette - Creative, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const violetLight: ColorPalette$4;
-/**
- * Violet dark palette - Creative, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const violetDark: ColorPalette$4;
-
-type ColorPalette$3 = Theme['colors'];
-/**
- * Amber light palette - Warm, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const amberLight: ColorPalette$3;
-/**
- * Amber dark palette - Warm, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const amberDark: ColorPalette$3;
-
-type ColorPalette$2 = Theme['colors'];
-/**
- * Cyan light palette - Fresh, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const cyanLight: ColorPalette$2;
 /**
- * Cyan dark palette - Fresh, accessible color scheme
- * Follows WCAG AA contrast guidelines
+ * Default light theme palette - V2
+ * A clean, modern palette using Indigo as primary and Slate as neutral
  */
-declare const cyanDark: ColorPalette$2;
-
-type ColorPalette$1 = Theme['colors'];
-/**
- * Slate light palette - Professional, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const slateLight: ColorPalette$1;
-/**
- * Slate dark palette - Professional, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const slateDark: ColorPalette$1;
-
-type ColorPalette = Theme['colors'];
-/**
- * Gray light palette - Clean, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const grayLight: ColorPalette;
-/**
- * Gray dark palette - Clean, accessible color scheme
- * Follows WCAG AA contrast guidelines
- */
-declare const grayDark: ColorPalette;
-
-/**
- * All available color palettes organized by name
- */
-declare const palettes: {
-    readonly indigo: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly blue: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly rose: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly emerald: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly teal: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly violet: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly amber: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly cyan: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly slate: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-    readonly gray: {
-        readonly light: BaseColors;
-        readonly dark: BaseColors;
-    };
-};
+declare const defaultPalette: BaseColors;
 
 /**
  * Extended type to support pseudo-classes, media queries, container queries, supports and complex selectors
@@ -741,6 +668,32 @@ type FontFaceOptions = {
  * ```
  */
 declare const createStyles: <TTheme extends Theme = Theme, T extends Record<string, StyleWithPseudos | StyleFunction> = Record<string, StyleWithPseudos | StyleFunction>>(stylesOrCreator: T | ((theme: TTheme) => T)) => { [K in keyof T]: T[K] extends (...args: infer TArgs) => StyleWithPseudos ? (...args: TArgs) => string : string; };
+/**
+ * Create a typed createStyles function pre-configured with your custom theme type.
+ * This eliminates the need to specify the theme type on every createStyles call.
+ *
+ * @example
+ * ```ts
+ * // 1. Define your custom theme
+ * type MyTheme = CustomTheme<{
+ *     brand: string
+ *     brandHover: string
+ *     surface: string
+ * }>
+ *
+ * // 2. Create a pre-typed createStyles function (do this once)
+ * export const createStyles = createTypedStyles<MyTheme>()
+ *
+ * // 3. Use it everywhere without specifying the type!
+ * const STYLES = createStyles((theme) => ({
+ *     button: {
+ *         backgroundColor: theme.colors.brand,    // ✅ TypeScript knows!
+ *         // backgroundColor: theme.colors.primary, // ❌ Error - doesn't exist
+ *     },
+ * }))
+ * ```
+ */
+declare const createTypedStyles: <TTheme extends Record<string, unknown>>() => <T extends Record<string, StyleWithPseudos | StyleFunction>>(stylesOrCreator: T | ((theme: TTheme) => T)) => { [K in keyof T]: T[K] extends (...args: infer TArgs) => StyleWithPseudos ? (...args: TArgs) => string : string; };
 
 /**
  * Create and inject keyframes
@@ -856,159 +809,4 @@ declare const insertRule: (rule: string) => void;
  */
 declare const sanitizeCssValue: (value: string) => string;
 
-/**
- * WCAG Contrast Utilities
- *
- * Utilities for checking color contrast ratios according to WCAG 2.1 guidelines.
- *
- * @example
- * ```ts
- * import { getContrastRatio, meetsWCAG, checkThemeContrast } from '@aurora-ds/theme'
- *
- * // Check contrast between two colors
- * const ratio = getContrastRatio('#ffffff', '#000000') // 21
- *
- * // Check if colors meet WCAG standards
- * meetsWCAG('#ffffff', '#767676', 'AA') // true for large text
- * meetsWCAG('#ffffff', '#767676', 'AAA') // false
- *
- * // Check all theme color pairs
- * const issues = checkThemeContrast(myTheme)
- * ```
- */
-/**
- * WCAG contrast level requirements
- * - AA: 4.5:1 for normal text, 3:1 for large text
- * - AAA: 7:1 for normal text, 4.5:1 for large text
- */
-type WCAGLevel = 'AA' | 'AAA';
-/**
- * Result of a contrast check
- */
-type ContrastResult = {
-    /** The two colors being compared */
-    colors: [string, string];
-    /** The contrast ratio (1-21) */
-    ratio: number;
-    /** Whether it passes WCAG AA for normal text (4.5:1) */
-    passesAA: boolean;
-    /** Whether it passes WCAG AA for large text (3:1) */
-    passesAALarge: boolean;
-    /** Whether it passes WCAG AAA for normal text (7:1) */
-    passesAAA: boolean;
-    /** Whether it passes WCAG AAA for large text (4.5:1) */
-    passesAAALarge: boolean;
-};
-/**
- * Theme contrast check result
- */
-type ThemeContrastIssue = {
-    /** Name of the color pair (e.g., "primary/onPrimary") */
-    pair: string;
-    /** Foreground color name */
-    foreground: string;
-    /** Background color name */
-    background: string;
-    /** The contrast ratio */
-    ratio: number;
-    /** Required minimum ratio */
-    required: number;
-    /** WCAG level that failed */
-    level: 'AA' | 'AALarge';
-};
-/**
- * Calculate the contrast ratio between two colors
- * @see https://www.w3.org/TR/WCAG21/#dfn-contrast-ratio
- *
- * @param foreground - Foreground color (hex)
- * @param background - Background color (hex)
- * @returns Contrast ratio (1-21), or null if colors are invalid
- *
- * @example
- * ```ts
- * getContrastRatio('#ffffff', '#000000') // 21
- * getContrastRatio('#ffffff', '#ffffff') // 1
- * getContrastRatio('#6366f1', '#ffffff') // ~4.5
- * ```
- */
-declare const getContrastRatio: (foreground: string, background: string) => number | null;
-/**
- * Check if two colors meet WCAG contrast requirements
- *
- * @param foreground - Foreground color (hex)
- * @param background - Background color (hex)
- * @param level - WCAG level to check ('AA' or 'AAA')
- * @param largeText - Whether this is for large text (14pt bold or 18pt+)
- * @returns Whether the contrast meets the specified WCAG level
- *
- * @example
- * ```ts
- * meetsWCAG('#ffffff', '#6366f1', 'AA') // true
- * meetsWCAG('#ffffff', '#6366f1', 'AAA') // false
- * meetsWCAG('#ffffff', '#94a3b8', 'AA', true) // true (large text)
- * ```
- */
-declare const meetsWCAG: (foreground: string, background: string, level?: WCAGLevel, largeText?: boolean) => boolean;
-/**
- * Get detailed contrast information between two colors
- *
- * @param foreground - Foreground color (hex)
- * @param background - Background color (hex)
- * @returns Detailed contrast result or null if colors are invalid
- *
- * @example
- * ```ts
- * const result = checkContrast('#ffffff', '#6366f1')
- * // {
- * //   colors: ['#ffffff', '#6366f1'],
- * //   ratio: 4.54,
- * //   passesAA: true,
- * //   passesAALarge: true,
- * //   passesAAA: false,
- * //   passesAAALarge: true
- * // }
- * ```
- */
-declare const checkContrast: (foreground: string, background: string) => ContrastResult | null;
-/**
- * Check all important color pairs in a theme for WCAG compliance
- *
- * @param theme - The theme to check
- * @param level - Minimum WCAG level to require ('AA' or 'AAA')
- * @returns Array of contrast issues found
- *
- * @example
- * ```ts
- * import { checkThemeContrast, defaultTheme } from '@aurora-ds/theme'
- *
- * const issues = checkThemeContrast(defaultTheme)
- * if (issues.length > 0) {
- *   console.warn('Theme has contrast issues:', issues)
- * }
- *
- * // Check for AAA compliance
- * const strictIssues = checkThemeContrast(defaultTheme, 'AAA')
- * ```
- */
-declare const checkThemeContrast: (theme: {
-    colors: Record<string, string>;
-}, level?: WCAGLevel) => ThemeContrastIssue[];
-/**
- * Get a suggested color that meets WCAG contrast requirements
- * Adjusts the lightness of the foreground color to meet the target ratio
- *
- * @param foreground - Current foreground color (hex)
- * @param background - Background color (hex)
- * @param targetRatio - Desired contrast ratio (default 4.5 for AA)
- * @returns Adjusted foreground color or null if adjustment isn't possible
- *
- * @example
- * ```ts
- * // If #94a3b8 on #ffffff doesn't meet AA
- * const suggested = suggestContrastColor('#94a3b8', '#ffffff', 4.5)
- * // Returns a darker shade that meets the requirement
- * ```
- */
-declare const suggestContrastColor: (foreground: string, background: string, targetRatio?: number) => string | null;
-
-export { type BaseBreakpoints, type BaseColors, type BaseFontSize, type BaseFontWeight, type BaseLineHeight, type BaseOpacity, type BaseRadius, type BaseShadows, type BaseSpacing, type BaseTransition, type BaseZIndex, type ColorName, type ColorScale, type ColorShade, type ContrastResult, type DeepPartial, type ExtendTheme, type ExtendedTheme, type FontFaceOptions, type PaletteName, type StyleFunction, type StyleWithPseudos, type Theme, type ThemeContrastIssue, type ThemeOverride, ThemeProvider, type ThemeProviderProps, type WCAGLevel, amber, amberDark, amberLight, black, blue, blueDark, blueLight, checkContrast, checkThemeContrast, clearSSRRules, colors, createStyles, createTheme, createThemeVariant, cssVar, cssVariables, current, cyan, cyanDark, cyanLight, defaultBreakpoints, defaultColors, defaultDarkColors, defaultDarkTheme, defaultFontSize, defaultFontWeight, defaultLineHeight, defaultOpacity, defaultRadius, defaultShadows, defaultSpacing, defaultTheme, defaultTransition, defaultZIndex, emerald, emeraldDark, emeraldLight, fontFace, fuchsia, getContrastRatio, getSSRRulesArray, getSSRStyleTag, getSSRStyles, getTheme, gray, grayDark, grayLight, green, indigo, indigoDark, indigoLight, injectCssVariables, insertRule, keyframes, lime, meetsWCAG, mergeThemes, orange, palettes, pink, purple, red, rose, roseDark, roseLight, sanitizeCssValue, setThemeContextGetter, sky, slate, slateDark, slateLight, stone, suggestContrastColor, teal, tealDark, tealLight, transparent, useTheme, violet, violetDark, violetLight, white, yellow };
+export { type BaseBreakpoints, type BaseColors, type BaseFontSize, type BaseFontWeight, type BaseLineHeight, type BaseOpacity, type BaseRadius, type BaseShadows, type BaseSpacing, type BaseTransition, type BaseZIndex, type ColorName, type ColorScale, type ColorShade, type CreateCustomThemeOptions, type CreateThemeOptions, type CustomTheme, type CustomThemeBase, type DeepPartial, type ExtendTheme, type ExtendedTheme, type FontFaceOptions, type StyleFunction, type StyleWithPseudos, type Theme, type ThemeOverride, ThemeProvider, type ThemeProviderProps, clearSSRRules, colors, createCustomTheme, createStyles, createTheme, createThemeVariant, createTypedStyles, cssVar, cssVariables, defaultBreakpoints, defaultFontSize, defaultFontWeight, defaultLineHeight, defaultOpacity, defaultPalette, defaultRadius, defaultShadows, defaultSpacing, defaultTheme, defaultTransition, defaultZIndex, fontFace, getSSRRulesArray, getSSRStyleTag, getSSRStyles, getTheme, injectCssVariables, insertRule, keyframes, mergeThemes, sanitizeCssValue, setThemeContextGetter, useTheme };