declare class HslColor {
    private hue;
    private saturation;
    private lightness;
    private alpha;
    constructor(hue: number, saturation: number, lightness: number, alpha?: number);
    get complementaryColor(): HslColor;
    get analogousColor(): HslColor[];
    get triadicColor(): HslColor[];
    toRgbColor(): RgbColor;
    private harmonize;
}

declare global {
    interface Number {
        correctGamma(): number;
    }
}
declare global {
    interface Number {
        correctGamma(): number;
        toDegrees(): number;
    }
}
declare global {
    interface Number {
        toRadians(): number;
    }
}
declare global {
    interface Number {
        reverseGammaCorrection(): number;
    }
}
declare global {
    interface Number {
        coerceAtMost(maximumValue: number): number;
    }
}
declare global {
    interface Number {
        coerceAtLeast(minimumValue: number): number;
    }
}
declare global {
    interface Number {
        coerceIn(minimumValue?: number, maximumValue?: number): number;
    }
}

declare class XyzColor {
    private x;
    private y;
    private z;
    private alpha;
    constructor(x: number, y: number, z: number, alpha?: number);
    toLabColor(): LabColor;
    toRgbColor(): RgbColor;
    private f;
}

declare class LabColor {
    private lightness;
    private a;
    private b;
    private alpha;
    constructor(lightness: number, a: number, b: number, alpha?: number);
    toLchColor(): LchColor;
    toXyzColor(): XyzColor;
    private fInv;
}

declare class LchColor {
    private lightness;
    private chroma;
    private hue;
    private alpha;
    constructor(lightness: number, chroma: number, hue: number, alpha?: number);
    getLightness(): number;
    getChroma(): number;
    deltaE(other: LchColor): number;
    toLabColor(): LabColor;
    minus(other: LchColor): LchColor;
    adjustLightness(block: (lightness: number) => number): LchColor;
    adjustChroma(block: (chroma: number) => number): LchColor;
    adjustHue(block: (hue: number) => number): LchColor;
    private hueDelta;
    private meanHue;
}

declare class RgbColor {
    private red;
    private green;
    private blue;
    private alpha;
    constructor(red: number, green: number, blue: number, alpha?: number);
    get rgbHex(): string;
    toLchColor(): LchColor;
    toHslColor(): HslColor;
    toXyzColor(): XyzColor;
}

declare const createPrimaryPalette: (hexColor: string) => RgbColor[] | null;
declare const createComplementaryPalette: (hexColor: string) => RgbColor[] | null;
declare const createAnalogousPalette: (hexColor: string) => RgbColor[][] | null;
declare const createTriadicPalette: (hexColor: string) => RgbColor[][] | null;
declare const toRgbColorOrNull: (hexColor: string) => RgbColor | null;

export { RgbColor, createAnalogousPalette, createComplementaryPalette, createPrimaryPalette, createTriadicPalette, toRgbColorOrNull };