declare const APCA_VERSION = "0.0.98G-4g";
/**
 * Calculate APCA contrast between foreground and background colors.
 *
 * APCA (Accessible Perceptual Contrast Algorithm) is polarity-aware:
 * - Positive values indicate dark text on light background
 * - Negative values indicate light text on dark background
 *
 * @param background - The background color string.
 * @param foreground - The foreground/text color string.
 * @returns Lc (Lightness contrast) value, roughly -108 to +106.
 */
declare function apcaContrast(background: string, foreground: string): number;

/**
 * Get the brightness difference between 2 colors.
 *
 * @param left - The first color string.
 * @param right - The second color string.
 * @param precision - The decimal precision (default: 5).
 * @returns The brightness difference value.
 */
declare function brightnessDifference(left: string, right: string, precision?: number): number;

/**
 * Get the chroma of a color.
 *
 * @param input - The input color string.
 * @returns The chroma value (0-1).
 */
declare function chroma(input: string): number;

/**
 * Get the color difference between 2 colors.
 *
 * @param left - The first color string.
 * @param right - The second color string.
 * @returns The color difference value.
 */
declare function colorDifference(left: string, right: string): number;

type ColorKeysTuple = [string, string, string];
type ColorModel = HSL | LAB | LCH | RGB;
type ColorModelKey = 'hsl' | 'oklab' | 'oklch' | 'rgb';
type ColorModelKeys<TModel extends ColorModelKey> = TModel extends 'hsl' ? keyof Omit<HSL, 'alpha'> : TModel extends 'oklab' ? keyof Omit<LAB, 'alpha'> : TModel extends 'oklch' ? keyof Omit<LCH, 'alpha'> : TModel extends 'rgb' ? keyof Omit<RGB, 'alpha'> : never;
type ColorReturn<T extends ColorType> = T extends 'hex' ? HEX : T extends 'hsl' ? HSL : T extends 'oklab' ? LAB : T extends 'oklch' ? LCH : T extends 'rgb' ? RGB : never;
type ColorTuple = [number, number, number];
type ColorType = 'hex' | 'hsl' | 'oklab' | 'oklch' | 'rgb';
type ColorTypeInput = ColorType | 'named';
type ConverterParameters<TModel extends ColorModel> = TModel | ColorTuple;
type HEX = `#${string}`;
type PlainObject<T = any> = Record<string, T>;
interface Analysis {
    brightnessDifference: number;
    colorDifference: number;
    compliant: number;
    contrast: number;
    largeAA: boolean;
    largeAAA: boolean;
    normalAA: boolean;
    normalAAA: boolean;
}
interface Colors {
    /** The alpha/opacity value (0-1). */
    alpha: number;
    hex: HEX;
    hsl: HSL;
    oklab: LAB;
    oklch: LCH;
    rgb: RGB;
    type: ColorType;
}
interface HSL {
    /** The alpha/opacity value (0-1). */
    alpha?: number;
    h: number;
    l: number;
    s: number;
}
interface LAB {
    a: number;
    /** The alpha/opacity value (0-1). */
    alpha?: number;
    b: number;
    l: number;
}
interface LCH {
    /** The alpha/opacity value (0-1). */
    alpha?: number;
    c: number;
    h: number;
    l: number;
}
interface RGB {
    /** The alpha/opacity value (0-1). */
    alpha?: number;
    b: number;
    g: number;
    r: number;
}

interface ColorizrOptions {
    /**
     * Output color format.
     *
     * If not specified, the output will use the same format as the input color.
     */
    format?: ColorType;
}
declare class Colorizr {
    /** The alpha/opacity value (0-1). */
    alpha: number;
    hex: HEX;
    hsl: HSL;
    oklab: LAB;
    oklch: LCH;
    rgb: RGB;
    type: ColorType;
    constructor(color: string | HSL | LAB | LCH | RGB, options?: ColorizrOptions);
    /**
     * Get CSS string
     */
    get css(): string;
    /**
     * Get the red value
     */
    get red(): number;
    /**
     * Get the green value
     */
    get green(): number;
    /**
     * Get the blue value
     */
    get blue(): number;
    /**
     * Get the hue value
     */
    get hue(): number;
    /**
     * Get the saturation value
     */
    get saturation(): number;
    /**
     * Get the lightness value
     */
    get lightness(): number;
    /**
     * Get the luminance value
     */
    get luminance(): number;
    /**
     * Get the chroma value
     */
    get chroma(): number;
    get opacity(): number;
    /**
     * Get the most readable color (light or dark) for this color as a background.
     */
    get readableColor(): string;
    private get currentColor();
    /**
     * Get the brightness difference between this color and another.
     *
     * @param input - The color to compare against.
     * @returns The brightness difference value.
     */
    brightnessDifference(input: string): number;
    /**
     * Get the color difference between this color and another.
     *
     * @param input - The color to compare against.
     * @returns The color difference value.
     */
    colorDifference(input: string): number;
    /**
     * Test 2 colors for WCAG compliance.
     *
     * @param input - The color to compare against.
     * @returns Analysis object with compliance information.
     */
    compare(input: string): Analysis;
    /**
     * Get the contrast ratio between this color and another.
     *
     * @param input - The color to compare against.
     * @returns The contrast ratio.
     */
    contrast(input: string): number;
    /**
     * Format the color to a specific type.
     *
     * @param type - The color format to convert to.
     * @param precision - The decimal precision for the output.
     * @returns The formatted color string.
     */
    format(type: ColorType, precision?: number): string;
    /**
     * Increase lightness.
     *
     * @param amount - A number between 0 and 100.
     * @returns The lightened color string.
     */
    lighten(amount: number): string;
    /**
     * Decrease lightness.
     *
     * @param amount - A number between 0 and 100.
     * @returns The darkened color string.
     */
    darken(amount: number): string;
    /**
     * Increase saturation.
     *
     * @param amount - A number between 0 and 100.
     * @returns The saturated color string.
     */
    saturate(amount: number): string;
    /**
     * Decrease saturation.
     *
     * @param amount - A number between 0 and 100.
     * @returns The desaturated color string.
     */
    desaturate(amount: number): string;
    /**
     * Convert to grayscale.
     *
     * @returns The grayscale color string.
     */
    grayscale(): string;
    /**
     * Invert color.
     *
     * @returns The inverted color string.
     */
    invert(): string;
    /**
     * Mix with another color.
     *
     * @param color - The color to mix with.
     * @param ratio - A number between 0 and 1 (0 = this color, 1 = input color).
     * @returns The mixed color string.
     */
    mix(color: string, ratio?: number): string;
    /**
     * Add opacity to the color.
     *
     * @param alpha - A number between 0 and 1.
     * @returns The opacified color string.
     */
    opacify(alpha?: number): string;
    /**
     * Rotate color hue.
     *
     * @param degrees - A number between -360 and 360.
     * @returns The rotated color string.
     */
    rotate(degrees: number): string;
    /**
     * Make the color more transparent.
     *
     * @param alpha - A number between -1 and 1.
     * @returns The transparentized color string.
     */
    transparentize(alpha?: number): string;
}

/**
 * Check 2 colors for WCAG compliance.
 *
 * @param left - The first color string.
 * @param right - The second color string.
 * @returns Analysis object with WCAG compliance information.
 */
declare function compare(left: string, right: string): Analysis;

/**
 * Get the contrast ratio between 2 colors.
 *
 * @param left - The first color string.
 * @param right - The second color string.
 * @returns The contrast ratio (1-21).
 */
declare function contrast(left: string, right: string): number;

/**
 * Convert a color string to another format.
 *
 * @param input - The input color string.
 * @param format - The output color format.
 * @returns The converted color string.
 */
declare function convert(input: string, format: ColorType): string;

/**
 * Convert HEX to HSL.
 *
 * @param input - The hex color string.
 * @returns The HSL color object.
 */
declare function hex2hsl(input: string): HSL;

/**
 * Convert HEX to OkLab.
 *
 * @param input - The hex color string.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLab color object.
 */
declare function hex2oklab(input: string, precision?: number): LAB;

/**
 * Convert HEX to OkLCH.
 *
 * @param input - The hex color string.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLCH color object.
 */
declare function hex2oklch(input: string, precision?: number): LCH;

/**
 * Convert HEX to RGB.
 *
 * @param input - The hex color string.
 * @returns The RGB color object.
 */
declare function hex2rgb(input: string): RGB;

/**
 * Convert HSL to HEX.
 *
 * @param input - The HSL color object or tuple.
 * @returns The hex color string.
 */
declare function hsl2hex(input: ConverterParameters<HSL>): HEX;

/**
 * Convert HSL to OkLab.
 *
 * @param input - The HSL color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLab color object.
 */
declare function hsl2oklab(input: ConverterParameters<HSL>, precision?: number): LAB;

/**
 * Convert HSL to OkLCH.
 *
 * @param input - The HSL color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLCH color object.
 */
declare function hsl2oklch(input: ConverterParameters<HSL>, precision?: number): LCH;

/**
 * Convert HSL to RGB.
 *
 * @param input - The HSL color object or tuple.
 * @returns The RGB color object.
 */
declare function hsl2rgb(input: ConverterParameters<HSL>): RGB;

/**
 * Convert OkLab to HEX.
 *
 * @param input - The OkLab color object or tuple.
 * @returns The hex color string.
 */
declare function oklab2hex(input: ConverterParameters<LAB>): HEX;

/**
 * Convert OkLab to HSL.
 *
 * @param input - The OkLab color object or tuple.
 * @returns The HSL color object.
 */
declare function oklab2hsl(input: ConverterParameters<LAB>): HSL;

/**
 * Convert OkLab to OkLCH.
 *
 * @param input - The OkLab color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLCH color object.
 */
declare function oklab2oklch(input: ConverterParameters<LAB>, precision?: number): LCH;

/**
 * Convert OkLab to RGB.
 *
 * @param input - The OkLab color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The RGB color object.
 */
declare function oklab2rgb(input: ConverterParameters<LAB>, precision?: number): RGB;

/**
 * Convert OkLCH to HEX.
 *
 * @param input - The OkLCH color object or tuple.
 * @returns The hex color string.
 */
declare function oklch2hex(input: ConverterParameters<LCH>): HEX;

/**
 * Convert OkLCH to HSL.
 *
 * @param input - The OkLCH color object or tuple.
 * @returns The HSL color object.
 */
declare function oklch2hsl(input: ConverterParameters<LCH>): HSL;

/**
 * Convert OkLCH to OkLab.
 *
 * @param input - The OkLCH color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLab color object.
 */
declare function oklch2oklab(input: ConverterParameters<LCH>, precision?: number): LAB;

/**
 * Convert OkLCH to RGB.
 *
 * @param input - The OkLCH color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The RGB color object.
 */
declare function oklch2rgb(input: ConverterParameters<LCH>, precision?: number): RGB;

/**
 * Convert RGB to HEX.
 *
 * @param input - The RGB color object or tuple.
 * @returns The hex color string.
 */
declare function rgb2hex(input: ConverterParameters<RGB>): HEX;

/**
 * Convert RGB to HSL.
 *
 * @param input - The RGB color object or tuple.
 * @returns The HSL color object.
 */
declare function rgb2hsl(input: ConverterParameters<RGB>): HSL;

/**
 * Convert RGB to OkLab.
 *
 * @param input - The RGB color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLab color object.
 */
declare function rgb2oklab(input: ConverterParameters<RGB>, precision?: number): LAB;

/**
 * Convert RGB to OkLCH.
 *
 * @param input - The RGB color object or tuple.
 * @param precision - The number of decimal places for the result.
 * @returns The OkLCH color object.
 */
declare function rgb2oklch(input: ConverterParameters<RGB>, precision?: number): LCH;

/**
 * Decrease color lightness.
 *
 * @param input - The input color string.
 * @param amount - A number between 0 and 100.
 * @param format - The output color format.
 * @returns The darkened color string.
 */
declare function darken(input: string, amount: number, format?: ColorType): string;

/**
 * Decrease color saturation.
 *
 * @param input - The input color string.
 * @param amount - A number between 0 and 100.
 * @param format - The output color format.
 * @returns The desaturated color string.
 */
declare function desaturate(input: string, amount: number, format?: ColorType): string;

type ExtractColorPartsReturn = {
    alpha?: number;
    model: ColorModelKey;
} & PlainObject<number>;
/**
 * Extract the color parts from a CSS color string.
 * Hex colors are supported via conversion.
 *
 * @param input - The CSS color string.
 * @returns An object with the color model and component values.
 */
declare function extractColorParts(input: string): ExtractColorPartsReturn;

interface FormatCSSOptions {
    /**
     * The alpha value of the color (0-1).
     */
    alpha?: number;
    /**
     * Output color format.
     * @default 'hex'
     */
    format?: ColorType;
    /**
     * The number of digits of the output.
     * @default 5
     */
    precision?: number;
    /**
     * The separator between the values.
     *
     * oklab and oklch always use space as a separator.
     * @default ' '
     */
    separator?: string;
}
/**
 * Format a color model to a CSS color string.
 *
 * @param input - The color model or hex string.
 * @param options - Formatting options.
 * @returns The formatted CSS color string.
 */
declare function formatCSS<T extends ColorModel | HEX>(input: T, options?: FormatCSSOptions): string;

/**
 * Normalize a hex color string to 6 or 8 characters.
 *
 * @param input - The hex color string (3, 4, 6, or 8 characters).
 * @returns The normalized hex color string.
 */
declare function formatHex(input: string): HEX;

/**
 * Detect the color type from a CSS color string.
 *
 * @param input - The color string to analyze.
 * @returns The detected color type ('hex', 'hsl', 'rgb', 'oklab', 'oklch', 'named'),
 *          or `null` if the input is not a valid color string.
 */
declare function getColorType(input: string): ColorTypeInput | null;

/**
 * Convert a color to grayscale using OkLCH (perceptually uniform).
 * Sets chroma to 0 while preserving lightness.
 *
 * @param input - The input color string.
 * @param format - The output color format.
 * @returns The grayscale color string.
 */
declare function grayscale(input: string, format?: ColorType): string;

/**
 * Invert the color by rotating hue 180 degrees.
 *
 * @param input - The input color string.
 * @returns The inverted color string in the same format as input.
 */
declare function invert(input: string): string;

/**
 * Check if a string is a valid CSS color.
 * Optionally validate against a specific color type.
 *
 * @param input - The color string to validate.
 * @param type - Optional color type to check against.
 * @returns True if the input is a valid color (of the specified type, if given).
 */
declare function isValidColor(input: string, type?: ColorTypeInput): boolean;

/**
 * Increase color lightness.
 *
 * @param input - The input color string.
 * @param amount - A number between 0 and 100.
 * @param format - The output color format.
 * @returns The lightened color string.
 */
declare function lighten(input: string, amount: number, format?: ColorType): string;

/**
 * Get the relative luminance of a color (WCAG definition).
 *
 * @param input - The input color string.
 * @returns The luminance value (0-1).
 */
declare function luminance(input: string): number;

/**
 * Mix two colors in OkLCH space (perceptually uniform).
 * Uses shortest-path hue interpolation.
 *
 * @param color1 - The first color string.
 * @param color2 - The second color string.
 * @param ratio - A number between 0 and 1 (0 = color1, 1 = color2).
 * @param format - Optional output color format.
 * @returns The mixed color string.
 */
declare function mix(color1: string, color2: string, ratio?: number, format?: ColorType): string;

/**
 * Add an alpha value to a hex string.
 *
 * @param input - The hex color string.
 * @param alpha - A number between 0 and 1.
 * @returns The hex color string with alpha.
 */
declare function addAlphaToHex(input: string, alpha: number): HEX;
/**
 * Convert an alpha value to a hex value.
 *
 * @param input - A number between 0 and 1 (values > 1 are divided by 100).
 * @returns The two-character hex string.
 */
declare function convertAlphaToHex(input: number): string;
/**
 * Extract the alpha value from a hex string.
 *
 * @param input - The hex color string.
 * @returns The alpha value (0-1), defaults to 1 if no alpha present.
 */
declare function extractAlphaFromHex(input: string): number;
/**
 * Convert a hexadecimal string to a number.
 *
 * @param input - The hexadecimal string.
 * @returns The numeric value.
 */
declare function hexadecimalToNumber(input: string): number;
/**
 * Remove the alpha value from a hex string.
 *
 * @param input - The hex color string.
 * @returns The hex color string without alpha.
 */
declare function removeAlphaFromHex(input: string): HEX;

/**
 * Get the step keys for a given step count.
 *
 * @param steps - The number of steps (clamped to 3-20).
 * @returns The array of step keys.
 */
declare function getScaleStepKeys(steps: number): number[];

declare function isHex(input: unknown): input is HEX;
/**
 * Check if an object contains HSL values
 * The input must be an object with keys 'h', 's', and 'l'
 * with values between 0 and 360 for hue or 0 and 100 for the others.
 */
declare function isHSL(input: unknown): input is HSL;
/**
 * Check if an object contains LAB values
 * The input must be an object with keys 'l', 'a', and 'b' with values between -1 and 1.
 */
declare function isLAB(input: unknown): input is LAB;
/**
 * Check if an object contains LAB values
 * The input must be an object with keys 'l', 'c', and 'h' with values between 0 and 360.
 */
declare function isLCH(input: unknown): input is LCH;
/**
 * Check if an object contains RGB values.
 * The input must be an object with keys 'r', 'g', and 'b' with values between 0 and 255.
 */
declare function isRGB(input: unknown): input is RGB;

/**
 * Get the CSS color name of a color.
 * Returns the hex value if no matching name is found.
 *
 * @param input - The input color string.
 * @returns The CSS color name or hex value.
 */
declare function name(input: string): string;

/**
 * Set the color opacity/alpha.
 *
 * @param input - The input color string.
 * @param alpha - A number between 0 and 1.
 * @param format - The output color format.
 * @returns The opacified color string.
 */
declare function opacify(input: string, alpha: number, format?: ColorType): string;

/**
 * Get the opacity/alpha value of a color.
 *
 * @param input - The input color string.
 * @returns The opacity value (0-1).
 */
declare function opacity(input: string): number;

/**
 * Get the maximum chroma for a given lightness and hue in the OkLCH color space.
 *
 * @param input - The input color string or LCH object.
 * @param precision - The number of decimal places for the result.
 * @returns The maximum chroma value within P3 gamut.
 */
declare function getOkLCHMaxChroma(input: string | LCH, precision?: number): number;
/**
 * Get an OkLCH color with maximum chroma in the P3 color space.
 *
 * @param input - The input color string or LCH object.
 * @returns The OkLCH color string with maximum chroma.
 */
declare function getP3MaxColor(input: string | LCH): string;

interface PaletteOptions {
    /**
     * Output color format.
     *
     * If not specified, the output will use the same format as the input color.
     */
    format?: ColorType;
    /**
     * Adjusts the lightness of the base color before generating the palette.
     *
     * Value should be between 0 and 100.
     */
    lightness?: number;
    /**
     * Adjusts the saturation of the base color before generating the palette.
     *
     * Value should be between 0 and 100.
     */
    saturation?: number;
    /**
     * The number of colors to generate in the palette.
     *
     * Minimum value is 2.
     * @default 6
     */
    size?: number;
    /**
     * Generate a monochromatic palette.
     *
     * For more options, use the `scale` function.
     */
    type?: 'monochromatic';
}
/**
 * Generate a color palette from a base color.
 *
 * @param input - The base color string.
 * @param options - Palette generation options.
 * @returns An array of color strings.
 */
declare function palette(input: string, options?: PaletteOptions): string[];

/**
 * Parse a CSS color string and optionally convert to a specific format.
 *
 * @param input - The CSS color string.
 * @param format - Optional output color format.
 * @returns The parsed color in the specified format.
 */
declare function parseCSS<T extends ColorType>(input: string, format?: T): ColorReturn<T>;

interface RandomOptions {
    /**
     * The color format to return.
     * @default 'hex'
     */
    format?: ColorType;
    /**
     * Maximum hue value (0-360).
     * @default 360
     */
    maxHue?: number;
    /**
     * Maximum lightness value (0-100).
     * @default 90
     */
    maxLightness?: number;
    /**
     * Maximum saturation value (0-100).
     * @default 100
     */
    maxSaturation?: number;
    /**
     * Minimum hue value (0-360).
     * If minHue > maxHue, the range wraps around 0° (e.g., 330-30 for reds).
     * @default 0
     */
    minHue?: number;
    /**
     * Minimum lightness value (0-100).
     * @default 10
     */
    minLightness?: number;
    /**
     * Minimum saturation value (0-100).
     * @default 10
     */
    minSaturation?: number;
}
/**
 * Generate a random color.
 *
 * @param options - Options to constrain the random color generation.
 * @returns The random color string.
 */
declare function random(options?: RandomOptions): string;

type ReadableColorMethod = 'apca' | 'contrast' | 'oklab' | 'wcag' | 'yiq';
interface ReadableColorOptions {
    /**
     * The dark color to return if the background is light.
     * @default '#000000'
     */
    darkColor?: string;
    /**
     * The light color to return if the background is dark.
     * @default '#ffffff'
     */
    lightColor?: string;
    /**
     * The method to use for determining contrast.
     *
     * - `yiq`: YIQ brightness formula (fast, simple)
     * - `wcag`: WCAG 2.x relative luminance threshold
     * - `contrast`: WCAG 2.x contrast ratio comparison
     * - `oklab`: OkLab perceptual lightness threshold
     * - `apca`: APCA contrast comparison (WCAG 3.0 candidate)
     *
     * @default 'yiq'
     */
    method?: ReadableColorMethod;
    /**
     * The threshold for threshold-based methods.
     *
     * - `yiq`: 0-255 (default: 128)
     * - `wcag`: 0-1 (default: 0.5)
     * - `oklab`: 0-1 (default: 0.5)
     * - `contrast` and `apca`: ignored (comparison-based)
     */
    threshold?: number;
}
/**
 * Get the most readable color (light or dark) for a given background.
 *
 * Supports multiple methods for determining contrast:
 * - `yiq`: Simple YIQ brightness formula (default, backwards compatible)
 * - `wcag`: WCAG 2.x relative luminance with threshold
 * - `contrast`: WCAG 2.x contrast ratio comparison
 * - `oklab`: OkLab perceptual lightness with threshold
 * - `apca`: APCA contrast comparison (WCAG 3.0 candidate)
 *
 * @param backgroundColor - The background color string.
 * @param options - Options for determining the readable color.
 * @returns The most readable color (light or dark).
 */
declare function readableColor(backgroundColor: string, options?: ReadableColorOptions): string;

interface ReadableColorAPCAOptions {
    /**
     * The dark color to return if it has better contrast.
     * @default '#000000'
     */
    darkColor?: string;
    /**
     * The light color to return if it has better contrast.
     * @default '#ffffff'
     */
    lightColor?: string;
}
/**
 * Get the most readable color for a given background using APCA contrast.
 *
 * APCA (Accessible Perceptual Contrast Algorithm) is the contrast method
 * proposed for WCAG 3.0. It's polarity-aware and provides more accurate
 * contrast predictions than WCAG 2.x contrast ratio.
 *
 * This function compares the APCA contrast of both light and dark options
 * against the background and returns the one with higher absolute contrast.
 *
 * @param backgroundColor - The background color string.
 * @param options - Options for the light and dark colors.
 * @returns The most readable color (light or dark).
 */
declare function readableColorAPCA(backgroundColor: string, options?: ReadableColorAPCAOptions): string;

/**
 * Change the color hue by rotating it.
 *
 * @param input - The input color string.
 * @param degrees - A number between -360 and 360.
 * @param format - The output color format.
 * @returns The rotated color string.
 */
declare function rotate(input: string, degrees: number, format?: ColorType): string;

/**
 * Increase color saturation.
 *
 * @param input - The input color string.
 * @param amount - A number between 0 and 100.
 * @param format - The output color format.
 * @returns The saturated color string.
 */
declare function saturate(input: string, amount: number, format?: ColorType): string;

type ScaleMode = 'light' | 'dark';
type ScaleVariant = 'deep' | 'neutral' | 'pastel' | 'subtle' | 'vibrant';
/**
 * Options for generating a color scale.
 *
 * **Option Precedence:**
 * - `saturation` overrides `variant` if both are set
 * - `lock` affects palette calculation: steps are distributed relative to the locked position
 * - `mode` affects lightness direction: 'light' has lightest at low keys, 'dark' reverses this
 */
interface ScaleOptions {
    /**
     * Controls chroma adjustment across lightness levels.
     * Values between 0-1 interpolate between these behaviors.
     *
     * @default 0
     */
    chromaCurve?: number;
    /**
     * Output color format.
     *
     * Determines the format of the generated colors (e.g., HEX, RGB, OKLCH, etc.).
     *
     * If not specified, the output will match the format of the input color.
     */
    format?: ColorType;
    /**
     * The lightness tuning factor for the scale.
     * - 1: Linear lightness distribution.
     * - >1: Lighter tones are emphasized.
     * - <1: Darker tones are emphasized.
     * @default 1.5
     */
    lightnessCurve?: number;
    /**
     * Lock input color at specific step position.
     *
     * The input color will appear exactly at this step, and other steps
     * will be calculated relative to this anchor point.
     *
     * Must be a valid step key for the current step count.
     * Default step keys (11 steps): 50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950.
     * Step keys vary based on the `steps` option (3-20 steps supported).
     */
    lock?: number;
    /**
     * The maximum lightness value for the scale.
     *
     * Defines the upper bound for the lightest color in the palette.
     *
     * A number between 0 and 1.
     * @default 0.97
     */
    maxLightness?: number;
    /**
     * The minimum lightness value for the scale.
     *
     * Defines the lower bound for the darkest color in the palette.
     *
     * A number between 0 and 1.
     *
     * @default 0.2
     */
    minLightness?: number;
    /**
     * Theme-aware lightness direction.
     *
     * - 'light': Low keys (50) are lightest, high keys (950) are darkest
     * - 'dark': Low keys (50) are darkest, high keys (950) are lightest
     *
     * @default 'light'
     */
    mode?: ScaleMode;
    /**
     * Global saturation override (0-100).
     *
     * When set, overrides the chroma for all generated shades.
     * Maps to chroma in OKLCH space.
     *
     * Overrides `variant` if both are set.
     */
    saturation?: number;
    /**
     * Number of steps in the scale (3-20).
     *
     * Controls how many color shades are generated.
     *
     * @default 11
     */
    steps?: number;
    /**
     * The variant of the scale.
     * - 'deep': Generates rich and bold tones with significantly reduced lightness.
     * - 'neutral': Generates muted tones by reducing chroma.
     * - 'pastel': Produces soft and airy tones with significant chroma reduction.
     * - 'subtle': Creates extremely desaturated tones, close to grayscale.
     * - 'vibrant': Enhances chroma for bold and striking tones.
     */
    variant?: ScaleVariant;
}
/**
 * Generate a scale of colors based on the input color.
 *
 * This utility is ideal for designers and developers who need dynamic color
 * palettes for UI themes, design systems, or data visualization. Supports
 * multiple modes, scales, and variants for flexibility.
 *
 * @param input - The base color string.
 * @param options - Scale generation options.
 * @returns A record of step keys to color strings.
 */
declare function scale(input: string, options?: ScaleOptions): Record<number, string>;

type Scheme = 'analogous' | 'complementary' | 'rectangle' | 'split' | 'split-complementary' | 'square' | 'tetradic' | 'triadic';
interface SchemeOptions {
    /**
     * Output color format.
     *
     * If not specified, the output will use the same format as the input color.
     */
    format?: ColorType;
    /**
     * The type of scheme to generate.
     * @default 'complementary'
     */
    type?: Scheme;
}
/**
 * Get a color scheme based on the input color.
 *
 * @param input - The base color string.
 * @param typeOrOptions - The scheme type or options object.
 * @returns An array of color strings forming the scheme.
 */
declare function scheme(input: string, typeOrOptions?: Scheme | SchemeOptions): string[];

/**
 * Increase the color transparency.
 *
 * @param input - The input color string.
 * @param alpha - A number between -1 and 1. Positive values increase transparency, negative values decrease transparency.
 * @param format - The output color format.
 * @returns The transparentized color string.
 */
declare function transparentize(input: string, alpha: number, format?: ColorType): string;

export { APCA_VERSION, type Analysis, type ColorKeysTuple, type ColorModel, type ColorModelKey, type ColorModelKeys, type ColorReturn, type ColorTuple, type ColorType, type ColorTypeInput, type ColorizrOptions, type Colors, type ConverterParameters, type FormatCSSOptions, type HEX, type HSL, type LAB, type LCH, type PaletteOptions, type PlainObject, type RGB, type ReadableColorAPCAOptions, type ReadableColorMethod, type ReadableColorOptions, type ScaleOptions, type ScaleVariant, type Scheme, type SchemeOptions, addAlphaToHex, apcaContrast, brightnessDifference, chroma, colorDifference, compare, contrast, convert, convertAlphaToHex, darken, Colorizr as default, desaturate, extractAlphaFromHex, extractColorParts, formatCSS, formatHex, getColorType, getOkLCHMaxChroma, getP3MaxColor, getScaleStepKeys, grayscale, hex2hsl, hex2oklab, hex2oklch, hex2rgb, hexadecimalToNumber, hsl2hex, hsl2oklab, hsl2oklch, hsl2rgb, invert, isHSL, isHex, isLAB, isLCH, isRGB, isValidColor, lighten, luminance, mix, name, oklab2hex, oklab2hsl, oklab2oklch, oklab2rgb, oklch2hex, oklch2hsl, oklch2oklab, oklch2rgb, opacify, opacity, palette, parseCSS, random, readableColor, readableColorAPCA, removeAlphaFromHex, rgb2hex, rgb2hsl, rgb2oklab, rgb2oklch, rotate, saturate, scale, scheme, transparentize };