import { P as PaletteConfig, d as EasingOption, e as Step, H as HexColor, R as Ramp, B as BrandArray, a as PaletteInput, b as PaletteOptions } from '../types-CJu_XF-I.js';
export { f as BrandCount, C as CvdType, g as EASING_KEYWORDS, E as EasingKeyword, M as ModePalette, h as PaletteVariant, i as PerMode, j as RAMP_NAMES, k as SEMANTIC_KEYS, l as SchemeInput, S as SchemeKind, c as SemanticTokens, m as cubicBezier, n as cubicBezierYAtX, o as easingWeightAtT, p as evaluateEasingY, r as resolveEasingControlPoints } from '../types-CJu_XF-I.js';

type Mode = "light" | "dark";
type Tier = "base" | "alias";
interface ThemeSourceToken {
    key: string;
    sourcePath: string;
    value: string;
    mode?: Mode;
    tier: Tier;
}
interface ThemeSourceIndex {
    tokens: ThemeSourceToken[];
    baseTokens: ThemeSourceToken[];
    aliasTokens: ThemeSourceToken[];
    exact: Map<string, ThemeSourceToken[]>;
}
interface ThemeMapperFuzzyOptions {
    enabled?: boolean;
    derivedAliases?: boolean;
    minScore?: number;
}
type ThemeMappingTemplate = Record<string, unknown>;
type ThemeMappingPathOverrides = Record<string, string>;
interface ThemeMappingConfig<TTemplate extends ThemeMappingTemplate> {
    template: TTemplate;
    mappings?: ThemeMappingPathOverrides;
    fuzzy?: ThemeMapperFuzzyOptions;
    preserveLiterals?: boolean;
    requiredPaths?: string[];
}
interface ThemeMappingResolution {
    targetPath: string;
    sourceKey: string;
    sourcePath: string;
    value: string;
    reason: "explicit" | "exact-base" | "exact-alias" | "fuzzy-base" | "fuzzy-alias";
}
interface ThemeMappingAmbiguous {
    targetPath: string;
    candidates: string[];
}
interface ThemeMappingUnresolved {
    targetPath: string;
    reason: string;
}
interface ThemeMappingDiagnostics {
    resolved: ThemeMappingResolution[];
    ambiguous: ThemeMappingAmbiguous[];
    unresolved: ThemeMappingUnresolved[];
    missingRequired: string[];
}
interface ThemeMappingResult<TTemplate extends ThemeMappingTemplate> {
    theme: TTemplate;
    diagnostics: ThemeMappingDiagnostics;
}
declare function buildThemeSourceIndex(palette: PaletteConfig, options?: {
    derivedAliases?: boolean;
}): ThemeSourceIndex;
declare function mapPaletteToTheme<TTemplate extends ThemeMappingTemplate>(palette: PaletteConfig, config: ThemeMappingConfig<TTemplate>): ThemeMappingResult<TTemplate>;

declare const STEPS: Step[];
/** Build a Ramp from a partial that has every step filled (by construction). */
declare function toRamp(partial: Partial<Ramp>): Ramp;
type RampFromAnchorOpts = {
    neonChromaRolloff: boolean;
    stepDepth?: number;
    easing?: EasingOption;
};
declare function generateRampFromAnchor(anchor: HexColor, mode: "light" | "dark", opts: RampFromAnchorOpts): {
    ramp: Ramp;
    gamutClampsApplied: number;
};
type NeutralRampOpts = {
    brandTint: boolean;
    neonChromaRolloff: boolean;
    stepDepth?: number;
    easing?: EasingOption;
};
declare function generateNeutralRamp(primaryAnchor: HexColor, mode: "light" | "dark", opts: NeutralRampOpts): {
    ramp: Ramp;
    gamutClampsApplied: number;
};

declare function assertBrandArray(arr: readonly string[], label: string): asserts arr is BrandArray;

declare function generatePalette(input: PaletteInput, options?: PaletteOptions): PaletteConfig;

export { BrandArray, EasingOption, HexColor, type NeutralRampOpts, PaletteConfig, PaletteInput, PaletteOptions, Ramp, type RampFromAnchorOpts, STEPS, Step, type ThemeMapperFuzzyOptions, type ThemeMappingConfig, type ThemeMappingDiagnostics, type ThemeMappingPathOverrides, type ThemeMappingResult, type ThemeMappingTemplate, type ThemeSourceIndex, type ThemeSourceToken, assertBrandArray, buildThemeSourceIndex, generateNeutralRamp, generatePalette, generateRampFromAnchor, mapPaletteToTheme, toRamp };