@nice2dev/design-tokens 1.0.28

package/dist/index.d.ts

@@ -0,0 +1,856 @@
+/**
+ * W3C Design Token types
+ * @see https://tr.designtokens.org/format/
+ */
+type TokenType = 'color' | 'dimension' | 'fontFamily' | 'fontWeight' | 'duration' | 'cubicBezier' | 'number' | 'strokeStyle' | 'border' | 'transition' | 'shadow' | 'gradient' | 'typography' | 'fontStyle';
+/**
+ * Shadow value (can be single or array of shadows)
+ */
+interface ShadowValue {
+    offsetX: string;
+    offsetY: string;
+    blur: string;
+    spread: string;
+    color: string;
+    inset?: boolean;
+}
+/**
+ * Typography composite value
+ */
+interface TypographyValue {
+    fontFamily: string;
+    fontSize: string;
+    fontWeight: string | number;
+    lineHeight?: string | number;
+    letterSpacing?: string;
+    fontStyle?: string;
+}
+/**
+ * Border composite value
+ */
+interface BorderValue {
+    color: string;
+    width: string;
+    style: string;
+}
+/**
+ * Gradient stop
+ */
+interface GradientStop {
+    color: string;
+    position: number;
+}
+/**
+ * Gradient value
+ */
+interface GradientValue {
+    type: 'linear' | 'radial' | 'conic';
+    angle?: number;
+    stops: GradientStop[];
+}
+/**
+ * Token value types
+ */
+type TokenValue = string | number | string[] | number[] | ShadowValue | ShadowValue[] | TypographyValue | BorderValue | GradientValue;
+/**
+ * Single design token
+ */
+interface DesignToken {
+    $value: TokenValue;
+    $type?: TokenType;
+    $description?: string;
+    $extensions?: Record<string, unknown>;
+}
+/**
+ * Token group (can contain tokens or nested groups)
+ */
+interface TokenGroup {
+    $type?: TokenType;
+    $description?: string;
+    $extensions?: Record<string, unknown>;
+    [key: string]: DesignToken | TokenGroup | TokenType | string | undefined | Record<string, unknown>;
+}
+/**
+ * Token file root
+ */
+interface TokenFile extends TokenGroup {
+    $name?: string;
+    $version?: string;
+    $description?: string;
+}
+/**
+ * Resolved (flattened) token with path
+ */
+interface ResolvedToken {
+    path: string[];
+    name: string;
+    value: TokenValue;
+    resolvedValue: string;
+    type?: TokenType;
+    description?: string;
+    cssVariable: string;
+    references?: string[];
+}
+/**
+ * Token collection (all resolved tokens)
+ */
+interface TokenCollection {
+    tokens: ResolvedToken[];
+    byPath: Map<string, ResolvedToken>;
+    byName: Map<string, ResolvedToken>;
+    /** Optional theme variants (e.g. dark, high-contrast) keyed by theme name. */
+    themes?: Record<string, ResolvedToken[]>;
+}
+/**
+ * Output format
+ */
+type OutputFormat = 'css' | 'scss' | 'js' | 'ts' | 'json' | 'tailwind';
+/**
+ * Generator options
+ */
+interface GeneratorOptions {
+    /** Output format(s) */
+    formats: OutputFormat[];
+    /** Output directory */
+    outputDir: string;
+    /** CSS variable prefix (default: 'nice') */
+    prefix?: string;
+    /** Include primitive tokens */
+    includePrimitives?: boolean;
+    /** Separate files by category */
+    separateFiles?: boolean;
+    /** Include dark mode */
+    includeDarkMode?: boolean;
+    /** Include component tokens */
+    includeComponents?: boolean;
+    /** Token file paths */
+    tokenFiles?: string[];
+}
+/**
+ * Theme definition
+ */
+interface ThemeDefinition {
+    name: string;
+    tokens: TokenCollection;
+    extends?: string;
+    selector?: string;
+    mediaQuery?: string;
+}
+/**
+ * Transform function
+ */
+type TokenTransform = (token: ResolvedToken) => string;
+/**
+ * Plugin for extending generator
+ */
+interface GeneratorPlugin {
+    name: string;
+    beforeResolve?: (tokens: TokenFile[]) => TokenFile[];
+    afterResolve?: (collection: TokenCollection) => TokenCollection;
+    customFormat?: (collection: TokenCollection, options: GeneratorOptions) => string;
+}
+
+/**
+ * Check if value is a design token (has $value)
+ */
+declare function isDesignToken(obj: unknown): obj is DesignToken;
+/**
+ * Check if value is a token group
+ */
+declare function isTokenGroup(obj: unknown): obj is TokenGroup;
+/**
+ * Check if value is a reference (e.g., "{color.blue.500}")
+ */
+declare function isReference(value: unknown): value is string;
+/**
+ * Extract reference path from reference string
+ */
+declare function extractReferencePath(ref: string): string[];
+/**
+ * Convert token path to CSS variable name
+ */
+declare function pathToCssVariable(path: string[], prefix?: string): string;
+/**
+ * Convert token path to dot notation
+ */
+declare function pathToString(path: string[]): string;
+/**
+ * Parse a single token file
+ */
+declare function parseTokenFile(filePath: string): TokenFile;
+/**
+ * Parse multiple token files and merge them
+ */
+declare function parseTokenFiles(filePaths: string[]): TokenFile;
+/**
+ * Merge two token files (source into target)
+ */
+declare function mergeTokenFiles(target: TokenFile, source: TokenFile): void;
+/**
+ * Flatten token file into resolved tokens
+ */
+declare function flattenTokens(tokenFile: TokenFile, prefix?: string[], inheritedType?: TokenType): ResolvedToken[];
+/**
+ * Find all references in a token value
+ */
+declare function findReferences(value: TokenValue, refs: string[]): void;
+/**
+ * Create a token collection from resolved tokens
+ */
+declare function createTokenCollection(tokens: ResolvedToken[]): TokenCollection;
+/**
+ * Parse all token files from a directory
+ */
+declare function parseTokenDirectory(dirPath: string, pattern?: string): TokenCollection;
+/**
+ * Get token by path
+ */
+declare function getTokenByPath(collection: TokenCollection, path: string | string[]): ResolvedToken | undefined;
+/**
+ * Filter tokens by type
+ */
+declare function filterTokensByType(collection: TokenCollection, type: TokenType): ResolvedToken[];
+/**
+ * Filter tokens by path prefix
+ */
+declare function filterTokensByPath(collection: TokenCollection, prefix: string): ResolvedToken[];
+/**
+ * Get all unique categories (top-level paths)
+ */
+declare function getCategories(collection: TokenCollection): string[];
+
+/**
+ * Default generator options
+ */
+declare const defaultOptions: GeneratorOptions;
+/**
+ * Token generator
+ */
+declare class TokenGenerator {
+    private options;
+    private plugins;
+    private collection;
+    private themes;
+    constructor(options?: Partial<GeneratorOptions>);
+    /**
+     * Add plugin
+     */
+    use(plugin: GeneratorPlugin): this;
+    /**
+     * Load tokens from files
+     */
+    load(files: string[]): this;
+    /**
+     * Load tokens from directory
+     */
+    loadDirectory(dir: string, pattern?: string): this;
+    /**
+     * Add theme
+     */
+    addTheme(name: string, overrideTokens?: TokenCollection): this;
+    /**
+     * Generate output files
+     */
+    generate(): Promise<void>;
+    /**
+     * Generate single format
+     */
+    private generateFormat;
+    /**
+     * Generate single output file
+     */
+    private generateSingleFile;
+    /**
+     * Generate separate files by category
+     */
+    private generateSeparateFiles;
+    /**
+     * Generate index file for separated files
+     */
+    private generateIndexFile;
+    /**
+     * Transform collection to format
+     */
+    private transform;
+    /**
+     * Build nested object from flat tokens
+     */
+    private buildNestedObject;
+    /**
+     * Get file extension for format
+     */
+    private getExtension;
+    /**
+     * Generate theme-related files
+     */
+    private generateThemeFiles;
+    /**
+     * Get generated token collection
+     */
+    getCollection(): TokenCollection | null;
+    /**
+     * Get generated themes
+     */
+    getThemes(): ThemeDefinition[];
+}
+/**
+ * Create generator instance
+ */
+declare function createGenerator(options?: Partial<GeneratorOptions>): TokenGenerator;
+/**
+ * Quick generate function
+ */
+declare function generateTokens(tokenDir: string, outputDir: string, options?: Partial<GeneratorOptions>): Promise<void>;
+
+/**
+ * Resolve all references in a token collection
+ */
+declare function resolveTokens(collection: TokenCollection): TokenCollection;
+/**
+ * Resolve a single token value
+ */
+declare function resolveTokenValue(value: TokenValue, collection: TokenCollection, depth: number): string;
+/**
+ * Resolve reference to CSS variable usage
+ */
+declare function resolveToVariable(value: TokenValue, collection: TokenCollection, _prefix?: string): string;
+/**
+ * Get dependency graph for tokens
+ */
+declare function getDependencyGraph(collection: TokenCollection): Map<string, Set<string>>;
+/**
+ * Topologically sort tokens by dependencies
+ */
+declare function sortTokensByDependencies(collection: TokenCollection): ResolvedToken[];
+/**
+ * Check for circular references
+ */
+declare function checkCircularReferences(collection: TokenCollection): string[][];
+
+/**
+ * Transform hex color to RGB
+ */
+declare function hexToRgb(hex: string): Promise<string>;
+/**
+ * Transform hex color to HSL
+ */
+declare function hexToHsl(hex: string): Promise<string>;
+/**
+ * Transform hex color to OKLCH (modern color space)
+ */
+declare function hexToOklch(hex: string): Promise<string>;
+/**
+ * Lighten a color by percentage
+ */
+declare function lightenColor(hex: string, amount: number): Promise<string>;
+/**
+ * Darken a color by percentage
+ */
+declare function darkenColor(hex: string, amount: number): Promise<string>;
+/**
+ * Calculate contrast ratio between two colors
+ */
+declare function getContrastRatio$1(fg: string, bg: string): Promise<number>;
+/**
+ * Find accessible text color for background
+ */
+declare function getAccessibleTextColor(bgColor: string): Promise<string>;
+/**
+ * Generate color scale from base color
+ */
+declare function generateColorScale$1(baseColor: string, steps?: number): Promise<Record<string, string>>;
+/**
+ * Transform dimension to rem
+ */
+declare function pxToRem(px: string | number, baseFontSize?: number): string;
+/**
+ * Transform rem to px
+ */
+declare function remToPx(rem: string | number, baseFontSize?: number): string;
+/**
+ * Transform dimension to em
+ */
+declare function pxToEm(px: string | number, context?: number): string;
+/**
+ * Transform font weight name to number
+ */
+declare function fontWeightToNumber(weight: string): number;
+/**
+ * Transform cubic bezier to CSS
+ */
+declare function cubicBezierToCss(values: number[]): string;
+/**
+ * Transform duration to milliseconds
+ */
+declare function durationToMs(duration: string): number;
+/**
+ * Transform tokens to CSS custom properties
+ */
+declare function transformToCss(collection: TokenCollection, prefix?: string): string;
+/**
+ * Transform tokens to SCSS variables
+ */
+declare function transformToScss(collection: TokenCollection, prefix?: string): string;
+/**
+ * Transform tokens to JavaScript object
+ */
+declare function transformToJs(collection: TokenCollection, variableName?: string): string;
+/**
+ * Transform tokens to TypeScript with types
+ */
+declare function transformToTs(collection: TokenCollection, variableName?: string): string;
+/**
+ * Build nested token object from flat collection
+ */
+declare function buildTokenObject(collection: TokenCollection): Record<string, unknown>;
+/**
+ * Generate TypeScript types for tokens
+ */
+declare function generateTokenTypes(collection: TokenCollection): string;
+/**
+ * Transform to Tailwind config format
+ */
+declare function transformToTailwind(collection: TokenCollection): string;
+
+/**
+ * Built-in theme modes
+ */
+type ThemeMode = 'light' | 'dark' | 'high-contrast' | 'high-contrast-dark' | 'dim';
+/**
+ * Theme configuration
+ */
+interface ThemeConfig {
+    /** Theme name */
+    name: string;
+    /** Display name */
+    displayName?: string;
+    /** Theme mode */
+    mode: ThemeMode;
+    /** CSS selector for theme */
+    selector: string;
+    /** Media query (for system preferences) */
+    mediaQuery?: string;
+    /** Parent theme to extend */
+    extends?: string;
+}
+/**
+ * Default theme configurations
+ */
+declare const defaultThemes: Record<ThemeMode, ThemeConfig>;
+/**
+ * Create theme definition from base tokens and overrides
+ */
+declare function createTheme(name: string, baseTokens: TokenCollection, overrideTokens?: TokenCollection, config?: Partial<ThemeConfig>): ThemeDefinition;
+/**
+ * Generate CSS for all themes
+ */
+declare function generateThemesCss(themes: ThemeDefinition[], prefix?: string): string;
+/**
+ * Generate theme switcher JavaScript
+ */
+declare function generateThemeSwitcher(): string;
+/**
+ * Generate React theme context
+ */
+declare function generateReactThemeContext(): string;
+/**
+ * Auto-generate dark mode tokens from light tokens
+ */
+declare function generateDarkModeTokens(lightTokens: TokenCollection): Promise<ResolvedToken[]>;
+/**
+ * Generate high contrast tokens
+ */
+declare function generateHighContrastTokens(baseTokens: TokenCollection, _minContrast?: number): Promise<ResolvedToken[]>;
+
+/**
+ * @file presets.ts
+ * @description Nice2Dev Design Tokens — Theme Presets
+ *
+ * 50+ ready-to-use theme presets for various brands and industries
+ */
+interface ThemePreset {
+    name: string;
+    displayName: string;
+    description: string;
+    category: PresetCategory;
+    colors: {
+        primary: ColorScale;
+        secondary?: ColorScale;
+        accent?: ColorScale;
+        neutral: ColorScale;
+        success: string;
+        warning: string;
+        error: string;
+        info: string;
+    };
+    typography?: {
+        fontFamily?: string;
+        headingFontFamily?: string;
+    };
+    borderRadius?: 'none' | 'sm' | 'md' | 'lg' | 'full';
+    shadows?: 'none' | 'sm' | 'md' | 'lg';
+}
+interface ColorScale {
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+    950: string;
+}
+type PresetCategory = 'brand' | 'healthcare' | 'finance' | 'education' | 'technology' | 'ecommerce' | 'entertainment' | 'government' | 'nature' | 'minimal' | 'bold' | 'playful' | 'professional';
+/**
+ * Generate color scale from a single base color
+ */
+declare function generateColorScale(baseColor: string): ColorScale;
+declare const PRESETS: ThemePreset[];
+/**
+ * Get presets by category
+ */
+declare function getPresetsByCategory(category: PresetCategory): ThemePreset[];
+/**
+ * Get preset by name
+ */
+declare function getPresetByName(name: string): ThemePreset | undefined;
+/**
+ * Get all categories
+ */
+declare function getAllCategories(): PresetCategory[];
+/**
+ * Convert preset to CSS variables
+ */
+declare function presetToCssVariables(preset: ThemePreset, prefix?: string): string;
+/**
+ * Convert preset to W3C Design Tokens format
+ */
+declare function presetToTokens(preset: ThemePreset): Record<string, unknown>;
+
+/**
+ * @file brand-kit.ts
+ * @description Nice2Dev Design Tokens — Brand Kit Generator
+ *
+ * Generate a complete theme from brand colors or logo
+ */
+
+interface BrandKitConfig {
+    /** Primary brand color (hex) */
+    primaryColor: string;
+    /** Secondary brand color (optional) */
+    secondaryColor?: string;
+    /** Accent color (optional) */
+    accentColor?: string;
+    /** Brand name */
+    brandName: string;
+    /** Industry/category for defaults */
+    industry?: BrandIndustry;
+    /** Preferred style */
+    style?: BrandStyle;
+    /** Typography preference */
+    typography?: TypographyPreference;
+    /** Border radius preference */
+    borderRadius?: 'none' | 'sm' | 'md' | 'lg' | 'full';
+    /** Shadow intensity */
+    shadows?: 'none' | 'sm' | 'md' | 'lg';
+}
+type BrandIndustry = 'technology' | 'healthcare' | 'finance' | 'education' | 'retail' | 'hospitality' | 'manufacturing' | 'creative' | 'nonprofit' | 'government';
+type BrandStyle = 'professional' | 'modern' | 'playful' | 'minimal' | 'bold' | 'luxury' | 'organic';
+type TypographyPreference = 'modern-sans' | 'classic-serif' | 'geometric' | 'rounded' | 'monospace';
+interface BrandKit {
+    preset: ThemePreset;
+    css: string;
+    tokens: Record<string, unknown>;
+    darkMode: ThemePreset;
+    assets: BrandAssets;
+}
+interface BrandAssets {
+    colorPalette: ColorPaletteAsset[];
+    typographyScale: TypographyScaleAsset[];
+    spacingScale: SpacingScaleAsset[];
+    logoUsageGuidelines: string;
+}
+interface ColorPaletteAsset {
+    name: string;
+    colors: {
+        shade: string;
+        hex: string;
+        usage: string;
+    }[];
+}
+interface TypographyScaleAsset {
+    name: string;
+    size: string;
+    weight: string | number;
+    lineHeight: string | number;
+    usage: string;
+}
+interface SpacingScaleAsset {
+    name: string;
+    value: string;
+    usage: string;
+}
+/**
+ * Analyze a color and generate complementary colors
+ */
+declare function analyzeColor(hex: string): {
+    hsl: [number, number, number];
+    rgb: [number, number, number];
+    luminance: number;
+    isLight: boolean;
+    complementary: string;
+    analogous: [string, string];
+    triadic: [string, string];
+    splitComplementary: [string, string];
+};
+/**
+ * Generate a complete brand kit from configuration
+ */
+declare function generateBrandKit(config: BrandKitConfig): BrandKit;
+/**
+ * Quick generate from just a primary color
+ */
+declare function quickBrandKit(primaryColor: string, brandName?: string): BrandKit;
+/**
+ * Generate brand kit for specific industry
+ */
+declare function industryBrandKit(primaryColor: string, brandName: string, industry: BrandIndustry): BrandKit;
+
+/**
+ * @file accessibility.ts
+ * @description Nice2Dev Design Tokens — Accessibility Features
+ *
+ * Reduced motion, high contrast, and accessibility-focused tokens
+ */
+interface ReducedMotionConfig {
+    /** Disable all animations */
+    disableAnimations?: boolean;
+    /** Use instant transitions instead of animated */
+    instantTransitions?: boolean;
+    /** Allow keyframe animations with reduced duration */
+    allowReducedAnimations?: boolean;
+    /** Maximum animation duration (ms) */
+    maxDuration?: number;
+    /** Disable parallax effects */
+    disableParallax?: boolean;
+    /** Disable auto-playing media */
+    disableAutoPlay?: boolean;
+}
+interface HighContrastConfig {
+    /** Minimum contrast ratio for text */
+    minTextContrast?: number;
+    /** Minimum contrast ratio for interactive elements */
+    minInteractiveContrast?: number;
+    /** Enhance focus indicators */
+    enhancedFocus?: boolean;
+    /** Use solid borders instead of shadows */
+    solidBorders?: boolean;
+    /** Increase font weight */
+    bolderText?: boolean;
+}
+interface AccessibilityTokens {
+    motion: MotionTokens;
+    focus: FocusTokens;
+    contrast: ContrastTokens;
+    typography: AccessibilityTypography;
+}
+interface MotionTokens {
+    duration: Record<string, string>;
+    easing: Record<string, string>;
+    transition: Record<string, string>;
+}
+interface FocusTokens {
+    ring: FocusRingConfig;
+    outline: FocusOutlineConfig;
+}
+interface FocusRingConfig {
+    width: string;
+    offset: string;
+    color: string;
+    style: string;
+}
+interface FocusOutlineConfig {
+    width: string;
+    style: string;
+    color: string;
+    offset: string;
+}
+interface ContrastTokens {
+    text: Record<string, string>;
+    background: Record<string, string>;
+    border: Record<string, string>;
+}
+interface AccessibilityTypography {
+    minSize: string;
+    lineHeight: string;
+    letterSpacing: string;
+    wordSpacing: string;
+}
+/**
+ * Standard motion tokens (full animations)
+ */
+declare const STANDARD_MOTION: MotionTokens;
+/**
+ * Reduced motion tokens (accessible)
+ */
+declare const REDUCED_MOTION: MotionTokens;
+/**
+ * Minimal motion tokens (limited animations)
+ */
+declare const MINIMAL_MOTION: MotionTokens;
+/**
+ * Standard focus indicators
+ */
+declare const STANDARD_FOCUS: FocusTokens;
+/**
+ * Enhanced focus indicators for accessibility
+ */
+declare const ENHANCED_FOCUS: FocusTokens;
+/**
+ * High visibility focus indicators
+ */
+declare const HIGH_VISIBILITY_FOCUS: FocusTokens;
+/**
+ * Standard contrast tokens
+ */
+declare const STANDARD_CONTRAST: ContrastTokens;
+/**
+ * High contrast tokens (WCAG AAA)
+ */
+declare const HIGH_CONTRAST: ContrastTokens;
+/**
+ * High contrast dark tokens
+ */
+declare const HIGH_CONTRAST_DARK: ContrastTokens;
+/**
+ * Standard typography accessibility settings
+ */
+declare const STANDARD_TYPOGRAPHY: AccessibilityTypography;
+/**
+ * Enhanced readability typography
+ */
+declare const ENHANCED_TYPOGRAPHY: AccessibilityTypography;
+/**
+ * Maximum readability typography
+ */
+declare const MAXIMUM_READABILITY_TYPOGRAPHY: AccessibilityTypography;
+/**
+ * Generate reduced motion CSS
+ */
+declare function generateReducedMotionCss(config?: ReducedMotionConfig): string;
+/**
+ * Generate enhanced focus CSS
+ */
+declare function generateFocusCss(tokens?: FocusTokens): string;
+/**
+ * Generate high contrast CSS
+ */
+declare function generateHighContrastCss(tokens?: ContrastTokens): string;
+/**
+ * Generate complete accessibility CSS
+ */
+declare function generateAccessibilityCss(options?: {
+    reducedMotion?: ReducedMotionConfig;
+    focus?: FocusTokens;
+    contrast?: ContrastTokens;
+    typography?: AccessibilityTypography;
+}): string;
+/**
+ * Standard accessibility tokens
+ */
+declare const STANDARD_ACCESSIBILITY: AccessibilityTokens;
+/**
+ * Enhanced accessibility tokens (WCAG AA)
+ */
+declare const ENHANCED_ACCESSIBILITY: AccessibilityTokens;
+/**
+ * Maximum accessibility tokens (WCAG AAA)
+ */
+declare const MAXIMUM_ACCESSIBILITY: AccessibilityTokens;
+/**
+ * Calculate contrast ratio between two colors
+ */
+declare function getContrastRatio(color1: string, color2: string): number;
+/**
+ * Check if contrast meets WCAG requirements
+ */
+declare function checkContrast(foreground: string, background: string, level?: 'AA' | 'AAA', isLargeText?: boolean): {
+    passes: boolean;
+    ratio: number;
+    required: number;
+};
+/**
+ * Suggest accessible color alternatives
+ */
+declare function suggestAccessibleColor(color: string, background: string, targetRatio?: number): string;
+
+/**
+ * @file css-only.ts
+ * @description Nice2Dev Design Tokens — CSS-Only Approach
+ *
+ * Generate pure CSS variables without CSS-in-JS dependencies.
+ * This module provides utilities for a CSS-variables-first approach
+ * that eliminates runtime CSS-in-JS overhead.
+ */
+
+interface CssOnlyConfig {
+    /** CSS variable prefix */
+    prefix?: string;
+    /** Include dark mode via media query */
+    includeDarkMode?: boolean;
+    /** Include high contrast via media query */
+    includeHighContrast?: boolean;
+    /** Include reduced motion via media query */
+    includeReducedMotion?: boolean;
+    /** Generate CSS layers */
+    useLayers?: boolean;
+    /** Output format */
+    format?: 'css' | 'scss' | 'postcss';
+    /** Include fallbacks for older browsers */
+    includeFallbacks?: boolean;
+    /** Generate container queries tokens */
+    containerQueries?: boolean;
+}
+interface CssLayer {
+    /** Layer name */
+    name: string;
+    /** Layer content */
+    content: string;
+}
+interface GeneratedCss {
+    /** Root variables */
+    root: string;
+    /** Dark mode overrides */
+    dark?: string;
+    /** High contrast overrides */
+    highContrast?: string;
+    /** Reduced motion styles */
+    reducedMotion?: string;
+    /** Utility classes */
+    utilities?: string;
+    /** Component reset */
+    reset?: string;
+    /** Combined output */
+    combined: string;
+}
+/**
+ * Generate CSS variables from token collection
+ */
+declare function tokensToCssVariables(tokens: TokenCollection, config?: CssOnlyConfig): GeneratedCss;
+/**
+ * Generate CSS from a theme preset
+ */
+declare function presetToCss(preset: ThemePreset, config?: CssOnlyConfig): string;
+/**
+ * Generate CSS-only component styles
+ */
+declare function generateComponentStyles(prefix?: string): string;
+/**
+ * Generate complete CSS stylesheet from preset
+ */
+declare function generateCompleteStylesheet(preset: ThemePreset, config?: CssOnlyConfig): string;
+
+export { type AccessibilityTokens, type AccessibilityTypography, type BorderValue, type BrandAssets, type BrandIndustry, type BrandKit, type BrandKitConfig, type BrandStyle, type ColorPaletteAsset, type ColorScale, type ContrastTokens, type CssLayer, type CssOnlyConfig, type DesignToken, ENHANCED_ACCESSIBILITY, ENHANCED_FOCUS, ENHANCED_TYPOGRAPHY, type FocusOutlineConfig, type FocusRingConfig, type FocusTokens, type GeneratedCss, type GeneratorOptions, type GeneratorPlugin, type GradientStop, type GradientValue, HIGH_CONTRAST, HIGH_CONTRAST_DARK, HIGH_VISIBILITY_FOCUS, type HighContrastConfig, MAXIMUM_ACCESSIBILITY, MAXIMUM_READABILITY_TYPOGRAPHY, MINIMAL_MOTION, type MotionTokens, type OutputFormat, PRESETS, type PresetCategory, REDUCED_MOTION, type ReducedMotionConfig, type ResolvedToken, STANDARD_ACCESSIBILITY, STANDARD_CONTRAST, STANDARD_FOCUS, STANDARD_MOTION, STANDARD_TYPOGRAPHY, type ShadowValue, type SpacingScaleAsset, type ThemeConfig, type ThemeDefinition, type ThemeMode, type ThemePreset, type TokenCollection, type TokenFile, TokenGenerator, type TokenGroup, type TokenTransform, type TokenType, type TokenValue, type TypographyPreference, type TypographyScaleAsset, type TypographyValue, analyzeColor, buildTokenObject, checkCircularReferences, checkContrast, createGenerator, createTheme, createTokenCollection, cubicBezierToCss, darkenColor, defaultOptions, defaultThemes, durationToMs, extractReferencePath, filterTokensByPath, filterTokensByType, findReferences, flattenTokens, fontWeightToNumber, generateAccessibilityCss, generateBrandKit, generateColorScale, generateColorScale$1 as generateColorScaleAsync, generateCompleteStylesheet, generateComponentStyles, generateDarkModeTokens, generateFocusCss, generateHighContrastCss, generateHighContrastTokens, generateReactThemeContext, generateReducedMotionCss, generateThemeSwitcher, generateThemesCss, generateTokenTypes, generateTokens, getAccessibleTextColor, getAllCategories, getCategories, getContrastRatio, getContrastRatio$1 as getContrastRatioAsync, getDependencyGraph, getPresetByName, getPresetsByCategory, getTokenByPath, hexToHsl, hexToOklch, hexToRgb, industryBrandKit, isDesignToken, isReference, isTokenGroup, lightenColor, mergeTokenFiles, parseTokenDirectory, parseTokenFile, parseTokenFiles, pathToCssVariable, pathToString, presetToCss, presetToCssVariables, presetToTokens, pxToEm, pxToRem, quickBrandKit, remToPx, resolveToVariable, resolveTokenValue, resolveTokens, sortTokensByDependencies, suggestAccessibleColor, tokensToCssVariables, transformToCss, transformToJs, transformToScss, transformToTailwind, transformToTs };