@aurora-ds/theme 2.0.1 → 3.1.0

package/dist/index.d.cts

@@ -2,330 +2,20 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, CSSProperties } from 'react';
 export { CSSProperties } from 'react';
 
-/**
- * Responsive breakpoints for mobile-first design
- * Based on common device widths
- *
- * - xs: Extra small devices (phones in portrait)
- * - sm: Small devices (phones in landscape, small tablets)
- * - md: Medium devices (tablets)
- * - lg: Large devices (desktops)
- * - xl: Extra large devices (large desktops)
- * - 2xl: Extra extra large devices (wide screens)
- */
-type BaseBreakpoints = {
-    xs: string;
-    sm: string;
-    md: string;
-    lg: string;
-    xl: string;
-    '2xl': string;
-};
-
-/**
- * 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;
-    primaryHover: string;
-    primaryActive: string;
-    primarySubtle: string;
-    primaryDisabled: string;
-    onPrimary: string;
-    secondary: string;
-    secondaryHover: string;
-    secondaryActive: string;
-    secondarySubtle: string;
-    secondaryDisabled: string;
-    onSecondary: string;
-    border: string;
-    disabled: string;
-    disabledText: string;
-    success: string;
-    successSubtle: string;
-    warning: string;
-    warningSubtle: string;
-    error: string;
-    errorHover: string;
-    errorSubtle: string;
-    onError: string;
-    info: string;
-    infoSubtle: string;
-    link: string;
-    linkHover: string;
-    linkActive: string;
-    linkDisabled: string;
-};
-
-/**
- * Spacing scale with semantic naming
- * Based on 4px unit system
- */
-type BaseSpacing = {
-    none: string;
-    '2xs': string;
-    xs: string;
-    sm: string;
-    md: string;
-    lg: string;
-    xl: string;
-    '2xl': string;
-    '3xl': string;
-    '4xl': string;
-    '5xl': string;
-};
-
-/**
- * Border radius scale
- */
-type BaseRadius = {
-    none: string;
-    xs: string;
-    sm: string;
-    md: string;
-    lg: string;
-    xl: string;
-    '2xl': string;
-    full: string;
-};
-
-/**
- * Shadow scale for elevation
- */
-type BaseShadows = {
-    none: string;
-    xs: string;
-    sm: string;
-    md: string;
-    lg: string;
-    xl: string;
-    '2xl': string;
-    inner: string;
-    focus: string;
-};
-
-/**
- * Font size scale
- */
-type BaseFontSize = {
-    '2xs': string;
-    xs: string;
-    sm: string;
-    md: string;
-    lg: string;
-    xl: string;
-    '2xl': string;
-    '3xl': string;
-    '4xl': string;
-    '5xl': string;
-};
-
-/**
- * Font weight scale
- */
-type BaseFontWeight = {
-    light: number;
-    regular: number;
-    medium: number;
-    semibold: number;
-    bold: number;
-};
-
-/**
- * Line height scale
- */
-type BaseLineHeight = {
-    none: number;
-    tight: number;
-    normal: number;
-    relaxed: number;
-    loose: number;
-};
-
-/**
- * Z-index scale for layering
- */
-type BaseZIndex = {
-    behind: number;
-    base: number;
-    dropdown: number;
-    sticky: number;
-    overlay: number;
-    modal: number;
-    popover: number;
-    tooltip: number;
-    toast: number;
-};
+/** Registry for theme type via module augmentation */
+interface ThemeRegistry {
+}
+/** @internal */
+type InferredTheme = ThemeRegistry extends {
+    theme: infer T;
+} ? T : Record<string, any>;
+/** Theme type, inferred from ThemeRegistry */
+type Theme<T = InferredTheme> = T extends Record<string, any> ? T : Record<string, any>;
 
 /**
- * Transition timing scale
+ * Creates a typed theme. Type is inferred from ThemeRegistry.
  */
-type BaseTransition = {
-    fast: string;
-    normal: string;
-    slow: string;
-};
-
-/**
- * Base opacity scale for consistent transparency
- */
-type BaseOpacity = {
-    /** Fully transparent - 0 */
-    none: number;
-    /** Very low opacity - 0.05 */
-    lowest: number;
-    /** Low opacity - 0.1 */
-    low: number;
-    /** Medium-low opacity - 0.25 */
-    medium: number;
-    /** Medium-high opacity - 0.5 */
-    high: number;
-    /** High opacity - 0.75 */
-    higher: number;
-    /** Fully opaque - 1 */
-    full: number;
-};
-
-/**
- * Standard theme type with all required tokens
- */
-type Theme = {
-    colors: BaseColors;
-    spacing: BaseSpacing;
-    radius: BaseRadius;
-    shadows: BaseShadows;
-    fontSize: BaseFontSize;
-    fontWeight: BaseFontWeight;
-    lineHeight: BaseLineHeight;
-    zIndex: BaseZIndex;
-    transition: BaseTransition;
-    opacity: BaseOpacity;
-    breakpoints: BaseBreakpoints;
-};
-
-/**
- * Generic theme type that allows extending base tokens
- */
-type ExtendedTheme<TColors extends BaseColors = BaseColors, TSpacing extends BaseSpacing = BaseSpacing, TRadius extends BaseRadius = BaseRadius, TShadows extends BaseShadows = BaseShadows, TFontSize extends BaseFontSize = BaseFontSize, TFontWeight extends BaseFontWeight = BaseFontWeight, TLineHeight extends BaseLineHeight = BaseLineHeight, TZIndex extends BaseZIndex = BaseZIndex, TTransition extends BaseTransition = BaseTransition, TExtensions extends Record<string, unknown> = Record<string, never>> = {
-    colors: TColors;
-    spacing: TSpacing;
-    radius: TRadius;
-    shadows: TShadows;
-    fontSize: TFontSize;
-    fontWeight: TFontWeight;
-    lineHeight: TLineHeight;
-    zIndex: TZIndex;
-    transition: TTransition;
-} & TExtensions;
-/**
- * Helper type to create a custom theme with extensions
- */
-type ExtendTheme<T extends Partial<Theme> & Record<string, unknown>> = Theme & T;
-/**
- * Utility type to deeply make all properties optional
- */
-type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-/**
- * 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'>>;
-};
+declare const createTheme: <T extends Record<string, unknown>>(values: T) => Theme<T>;
 
 /**
  * Color scale type - 12 shades from 25 to 950
@@ -345,237 +35,7 @@ type ColorScale = {
     950: string;
 };
 
-/**
- * Available color scale names
- */
-type ColorName = 'gray' | 'slate' | 'stone' | 'red' | 'orange' | 'amber' | 'yellow' | 'lime' | 'green' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose';
-
-/**
- * Available shade values (keys of ColorScale)
- */
-type ColorShade = keyof ColorScale;
-
-type ThemeProviderProps<T extends Theme = Theme> = {
-    theme: T;
-    children?: ReactNode;
-};
-/**
- * Theme provider component
- * Provides theme context to all child components
- *
- * @example
- * ```tsx
- * // With default theme
- * <ThemeProvider theme={defaultTheme}>
- *     <App />
- * </ThemeProvider>
- *
- * // With custom extended theme
- * <ThemeProvider theme={myCustomTheme}>
- *     <App />
- * </ThemeProvider>
- * ```
- */
-declare const ThemeProvider: <T extends Theme>({ theme, children }: ThemeProviderProps<T>) => react_jsx_runtime.JSX.Element;
-/**
- * Hook to access the current theme
- * Use the generic parameter to get proper typing for extended themes
- *
- * @example
- * ```tsx
- * // Basic usage
- * const theme = useTheme()
- *
- * // With custom theme type
- * const theme = useTheme<MyCustomTheme>()
- * ```
- *
- * @throws {Error} If used outside a ThemeProvider
- */
-declare const useTheme: <T extends Theme = Theme>() => T;
-
-/**
- * Default spacing scale
- */
-declare const defaultSpacing: Theme['spacing'];
-/**
- * Default border radius scale
- */
-declare const defaultRadius: Theme['radius'];
-/**
- * Default shadow scale
- */
-declare const defaultShadows: Theme['shadows'];
-/**
- * Default font size scale
- */
-declare const defaultFontSize: Theme['fontSize'];
-/**
- * Default font weight scale
- */
-declare const defaultFontWeight: Theme['fontWeight'];
-/**
- * Default line height scale
- */
-declare const defaultLineHeight: Theme['lineHeight'];
-/**
- * Default z-index scale
- */
-declare const defaultZIndex: Theme['zIndex'];
-/**
- * Default transition scale
- */
-declare const defaultTransition: Theme['transition'];
-/**
- * Default opacity scale
- */
-declare const defaultOpacity: Theme['opacity'];
-/**
- * Default responsive breakpoints
- */
-declare const defaultBreakpoints: Theme['breakpoints'];
-/**
- * Complete default theme V2
- */
-declare const defaultTheme: Theme;
-
-/**
- * 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 createTheme: <T extends Theme>(baseTheme: T, overrides: DeepPartial<T>, options?: CreateThemeOptions) => 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;
-/**
- * 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>;
-
-/**
- * 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
- */
+/** All color scales (19 scales with 12 shades each) */
 declare const colors: {
     readonly gray: ColorScale;
     readonly slate: ColorScale;
@@ -589,7 +49,6 @@ declare const colors: {
     readonly emerald: ColorScale;
     readonly teal: ColorScale;
     readonly cyan: ColorScale;
-    readonly sky: ColorScale;
     readonly blue: ColorScale;
     readonly indigo: ColorScale;
     readonly violet: ColorScale;
@@ -603,15 +62,39 @@ declare const colors: {
     readonly current: "currentColor";
 };
 
+type ThemeProviderProps = {
+    theme: Theme;
+    children?: ReactNode;
+};
 /**
- * Default light theme palette - V2
- * A clean, modern palette using Indigo as primary and Slate as neutral
+ * Provides the theme to all child components.
+ *
+ * @example
+ * ```tsx
+ * <ThemeProvider theme={lightTheme}>
+ *   <App />
+ * </ThemeProvider>
+ * ```
  */
-declare const defaultPalette: BaseColors;
-
+declare const ThemeProvider: ({ theme, children }: ThemeProviderProps) => react_jsx_runtime.JSX.Element;
 /**
- * Extended type to support pseudo-classes, media queries, container queries, supports and complex selectors
+ * Hook to access the current theme.
+ *
+ * Type is automatically inferred from ThemeRegistry (module augmentation).
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const theme = useTheme()
+ *   return <div style={{ color: theme.colors.primary }} />
+ * }
+ * ```
+ *
+ * @throws {Error} If used outside a ThemeProvider
  */
+declare const useTheme: () => Theme;
+
+/** CSS properties with support for pseudo-classes, media/container queries, and complex selectors */
 type StyleWithPseudos = CSSProperties & {
     [key: `:${string}`]: CSSProperties;
     [key: `@media ${string}`]: CSSProperties;
@@ -619,194 +102,47 @@ type StyleWithPseudos = CSSProperties & {
     [key: `@supports ${string}`]: CSSProperties;
     [key: `& ${string}` | `&>${string}` | `&:${string}` | `&[${string}`]: CSSProperties;
 };
-/**
- * Type for a function that returns StyleWithPseudos with any parameters
- */
+/** Function that returns StyleWithPseudos */
 type StyleFunction = (...args: never[]) => StyleWithPseudos;
-/**
- * Type for @font-face options
- */
+/** Options for @font-face */
 type FontFaceOptions = {
-    /** Font family name */
     fontFamily: string;
-    /** Font source(s) - URL or local() */
     src: string;
-    /** Font style */
     fontStyle?: 'normal' | 'italic' | 'oblique';
-    /** Font weight */
     fontWeight?: number | string;
-    /** Display behavior */
     fontDisplay?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
-    /** Unicode character range */
     unicodeRange?: string;
 };
 
 /**
- * Create typed styles with support for pseudo-classes, media queries, container queries, feature queries and complex selectors
- *
- * Supports custom extended themes via generic parameter.
- *
- * @example
- * ```ts
- * // Basic usage with default theme
- * const STYLES = createStyles((theme) => ({
- *     root: {
- *         display: 'flex',
- *         padding: theme.spacing.md,
- *         ':hover': { backgroundColor: theme.colors.backgroundHover },
- *     }
- * }))
- *
- * // With custom extended theme
- * type MyTheme = Theme & { colors: BaseColors & { accent: string } }
- *
- * const STYLES = createStyles<MyTheme>((theme) => ({
- *     root: {
- *         backgroundColor: theme.colors.accent, // TypeScript knows about accent!
- *     }
- * }))
- * ```
- */
-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
- *     },
- * }))
- * ```
+ * Creates styles with theme support. Type is inferred from ThemeRegistry.
+ * Supports pseudo-classes, media queries, and complex selectors.
  */
-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; };
+declare const createStyles: <T extends Record<string, StyleWithPseudos | StyleFunction> = Record<string, StyleWithPseudos | StyleFunction>>(stylesOrCreator: T | ((theme: Theme) => T)) => { [K in keyof T]: T[K] extends (...args: infer TArgs) => StyleWithPseudos ? (...args: TArgs) => string : string; };
 
-/**
- * Create and inject keyframes
- *
- * @example
- * ```ts
- * const fadeIn = keyframes({
- *     from: { opacity: 0 },
- *     to: { opacity: 1 }
- * })
- *
- * const STYLES = createStyles({
- *     animated: { animation: `${fadeIn} 0.3s ease-in-out` }
- * })
- * ```
- */
+/** Creates and injects a @keyframes rule, returns the animation name */
 declare const keyframes: (frames: Record<string, CSSProperties>) => string;
 
-/**
- * Inject a @font-face rule
- *
- * @example
- * ```ts
- * fontFace({
- *     fontFamily: 'MyFont',
- *     src: "url('/fonts/myfont.woff2') format('woff2')",
- *     fontWeight: 400,
- *     fontStyle: 'normal',
- *     fontDisplay: 'swap'
- * })
- * ```
- */
+/** Injects a @font-face rule and returns the font family name */
 declare const fontFace: (options: FontFaceOptions) => string;
 
-/**
- * Create CSS variables from the theme
- * Injects variables into :root
- *
- * @example
- * ```ts
- * // In ThemeProvider
- * injectCssVariables(theme, 'aurora')
- * // Generates: :root { --aurora-colors-primary: #2563EB; ... }
- * ```
- */
+/** Injects CSS variables from theme into :root */
 declare const injectCssVariables: (theme: Theme, prefix?: string) => void;
-/**
- * Helper to use a CSS variable from the theme
- *
- * @example
- * ```ts
- * const STYLES = createStyles({
- *     root: { color: cssVar('colors-primary') }
- * })
- * // Generates: color: var(--theme-colors-primary)
- * ```
- */
+/** Returns a CSS var() reference for a theme path */
 declare const cssVar: (path: string, fallback?: string) => string;
-/**
- * Create CSS variable references from a typed object
- * Returns an object with the same structure where values are var() references
- *
- * @example
- * ```ts
- * const vars = cssVariables({
- *     primaryColor: '#007bff',
- *     spacing: '1rem',
- * })
- * // vars.primaryColor === 'var(--primary-color)'
- * ```
- */
+/** Creates CSS variable references from an object */
 declare const cssVariables: <T extends Record<string, string | number>>(variables: T, options?: {
     prefix?: string;
     inject?: boolean;
 }) => { [K in keyof T]: string; };
 
-/**
- * SSR: Get all collected CSS rules as a single string
- * @returns The CSS content to inject into HTML
- */
+/** SSR: Returns all collected CSS rules as a single string */
 declare const getSSRStyles: () => string;
-/**
- * SSR: Get styles as a <style> tag ready to inject
- * @returns The complete style tag to inject into <head>
- */
+/** SSR: Returns styles wrapped in a style tag */
 declare const getSSRStyleTag: () => string;
-/**
- * SSR: Clear the collected rules buffer
- * Call at the beginning of each SSR request to ensure clean state
- */
+/** SSR: Clears the collected rules buffer */
 declare const clearSSRRules: () => void;
-/**
- * SSR: Get raw CSS rules as an array
- * @returns Array of CSS rules
- */
+/** SSR: Returns raw CSS rules as an array */
 declare const getSSRRulesArray: () => string[];
 
-/**
- * Set the theme getter
- */
-declare const setThemeContextGetter: (getter: (() => Theme | undefined) | null) => (() => Theme | undefined) | null;
-/**
- * Get the current theme
- */
-declare const getTheme: () => Theme | undefined;
-/**
- * Insert a CSS rule
- */
-declare const insertRule: (rule: string) => void;
-/**
- * Sanitize a CSS value to prevent injection attacks
- * Returns the sanitized value or 'unset' if the value is dangerous
- */
-declare const sanitizeCssValue: (value: string) => string;
-
-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 };
+export { type FontFaceOptions, type StyleFunction, type StyleWithPseudos, type Theme, ThemeProvider, type ThemeProviderProps, type ThemeRegistry, clearSSRRules, colors, createStyles, createTheme, cssVar, cssVariables, fontFace, getSSRRulesArray, getSSRStyleTag, getSSRStyles, injectCssVariables, keyframes, useTheme };