type ColorSpace = "rgb" | "hsl" | "hsv" | "hwb" | "cmyk" | "xyz" | "lab" | "lch" | "hex" | "keyword";
type Format = "object" | "array" | "string" | "css";
type FormatResult<T extends ColorSpace> = {
    [key in Format]: key extends "object" ? ColorObject<T> : key extends "array" ? ColorArray<T> : key extends "string" ? ColorString<T> : key extends "css" ? ColorCSS<T> : never;
};
type ColorObject<T extends ColorSpace> = T extends "rgb" ? ColorRGB : never;
type ColorArray<T extends ColorSpace> = T extends "rgb" ? TColorRGB : never;
type ColorString<T extends ColorSpace> = T extends "rgb" ? StringColorRGB : never;
type ColorCSS<T extends ColorSpace> = T extends "rgb" ? CssColorRGB : never;
type RGB_R = number;
type RGB_G = number;
type RGB_B = number;
type Alpha = number;
type TColorRGB = [RGB_R, RGB_G, RGB_B, Alpha];
type ColorRGB = {
    r: RGB_R;
    g: RGB_G;
    b: RGB_B;
    a: Alpha;
};
type StringColorRGB = string;
type CssColorRGB = string;

declare const IS_MYCOLOR: unique symbol;
declare const mycolor: {
    <CS extends "rgb" = "rgb">(...args: unknown[]): RGBColor;
    extend<T = unknown>(plugin: ColorPluginFn<T>, option?: T): void;
};
type OptionalTupleLast<T extends any[]> = T extends [...infer U, infer L] ? [...U, L?] : never;
type InputColor<CS extends ColorSpace = "rgb"> = CS extends "rgb" ? OptionalTupleLast<TColorRGB> : never;
interface Option {
    cs?: ColorSpace;
}
interface Cfg<CS extends ColorSpace = "rgb"> {
    color: InputColor<CS>;
    args?: [...Cfg<CS>["color"], Option];
}
declare abstract class Color<CS extends ColorSpace> {
    abstract [IS_MYCOLOR]: boolean;
    abstract parse(cfg: Cfg<CS>): void;
    abstract clone(): Color<CS>;
    abstract format<T extends Format = Format>(f: T): FormatResult<CS>[T];
}
interface RGB<CS extends Extract<ColorSpace, "rgb"> = "rgb"> {
    /** @description Get rgba array by standard methods */
    rgba(): TColorRGB;
    red(): RGB_R;
    red(r: RGB_R): Color<CS>;
    green(): RGB_G;
    green(g: RGB_G): Color<CS>;
    blue(): RGB_B;
    blue(b: RGB_B): Color<CS>;
    alpha(): Alpha;
    alpha(a: Alpha): Color<CS>;
}
declare class RGBColor<CS extends Extract<ColorSpace, "rgb"> = "rgb"> extends Color<CS> implements RGB {
    private r;
    private g;
    private b;
    private a;
    [IS_MYCOLOR]: boolean;
    constructor(cfg: Cfg<CS>);
    /** @internal */
    parse(cfg: Cfg<CS>): void;
    clone(): RGBColor;
    rgba(): TColorRGB;
    red(): RGB_R;
    red(r: RGB_R): RGBColor<CS>;
    green(): RGB_G;
    green(g: RGB_G): RGBColor<CS>;
    blue(): RGB_B;
    blue(b: RGB_B): RGBColor<CS>;
    alpha(): Alpha;
    alpha(a: Alpha): RGBColor<CS>;
}
interface ColorPlugin<T = unknown> {
    (option: T | undefined, mycolorClass: typeof RGBColor, mycolorFactory: typeof mycolor): void;
}
interface ColorPluginFn<T = unknown> extends ColorPlugin<T> {
    $i?: boolean;
}
type MyColorFn = typeof mycolor;

export { type Cfg, type ColorPlugin, type InputColor, RGBColor as MyColor, type MyColorFn, mycolor as default, mycolor };