/**
 * Representation color and transparency (RGBA).
 *
 * @example
 *  const red = new Color(1,0,0);
 *
 * @extends {Array.<number>}
 * @class
 */
export class Color {
    /**
     *
     * @param {number[]|Float32Array} source
     * @param {number} [offset]
     * @returns {Color}
     */
    static fromArray(source: number[] | Float32Array, offset?: number): Color;
    /**
     *
     * @param {number} r
     * @param {number} g
     * @param {number} b
     * @returns {Color}
     */
    static fromRGB(r: number, g: number, b: number): Color;
    /**
     *
     * @param {number} h
     * @param {number} s
     * @param {number} v
     * @return {Color}
     */
    static fromHSV(h: number, s: number, v: number): Color;
    /**
     * Create a color for numeric or string representation. Supports most CSS color representations.
     * @example
     *  Color.parse("#FF00FF");
     *  Color.parse(0xFF00FF);
     *  Color.parse("rgb(255, 0, 255)");
     *  Color.parse("rgba(255, 0, 255, 0.5)");
     *  Color.parse("hsv(0.5, 1, 0.3)");
     *
     * @param {string|number} value
     * @return {Color}
     * @throws Error if format could not be parsed
     */
    static parse(value: string | number): Color;
    /**
     *
     * @param {Color} input
     * @param {Color} [output]
     * @returns {Color}
     */
    static from_linear_to_sRGB(input: Color, output?: Color): Color;
    /**
     *
     * @param {Color} input
     * @param {Color} [output]
     * @returns {Color}
     */
    static from_sRGB_to_linear(input: Color, output?: Color): Color;
    /**
     *
     * @param {number} [r=0] Red from 0 to 1 for SDR
     * @param {number} [g=0] Green from 0 to 1 for SDR
     * @param {number} [b=0] Blue from 0 to 1 for SDR
     * @param {number} [a=1] Alpha from 0 to 1 (transparency)
     */
    constructor(r?: number, g?: number, b?: number, a?: number);
    /**
     * Red channel
     * Value from 0 to 1 for SDR
     * @type {number}
     */
    r: number;
    /**
     * Green channel
     * Value from 0 to 1 for SDR
     * @type {number}
     */
    g: number;
    /**
     * Blue channel
     * Value from 0 to 1 for SDR
     * @type {number}
     */
    b: number;
    /**
     * Alpha channel (transparency)
     * Value from 0 to 1
     * @type {number}
     */
    a: number;
    /**
     * @readonly
     * @type {Signal<number,number,number,number, number,number,number,number>}
     */
    readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
    /**
     *
     * @param {number} v
     */
    set 0(arg: number);
    /**
     *
     * @returns {number}
     */
    get 0(): number;
    /**
     *
     * @param {number} v
     */
    set 1(arg: number);
    /**
     *
     * @returns {number}
     */
    get 1(): number;
    /**
     *
     * @param {number} v
     */
    set 2(arg: number);
    /**
     *
     * @returns {number}
     */
    get 2(): number;
    /**
     *
     * @param {number} v
     */
    set 3(arg: number);
    /**
     *
     * @returns {number}
     */
    get 3(): number;
    /**
     *
     * @param {number} v
     */
    set x(arg: number);
    /**
     *
     * @returns {number}
     */
    get x(): number;
    /**
     *
     * @param {number} v
     */
    set y(arg: number);
    /**
     *
     * @returns {number}
     */
    get y(): number;
    /**
     *
     * @param {number} v
     */
    set z(arg: number);
    /**
     *
     * @returns {number}
     */
    get z(): number;
    /**
     *
     * @param {number} v
     */
    set w(arg: number);
    /**
     *
     * @returns {number}
     */
    get w(): number;
    /**
     * Pretending to be an array
     * @return {number}
     */
    get length(): number;
    /**
     *
     * @param {number} r
     * @param {number} g
     * @param {number} b
     */
    setRGB(r: number, g: number, b: number): void;
    /**
     *
     * @param {number} r in range of 0..255
     * @param {number} g in range of 0..255
     * @param {number} b in range of 0..255
     */
    setRGBUint8(r: number, g: number, b: number): void;
    /**
     * set alpha
     * @param {number} a
     */
    setA(a: number): void;
    /**
     *
     * @param {number} r
     * @param {number} g
     * @param {number} b
     * @param {number} a
     * @returns {this}
     */
    set(r: number, g: number, b: number, a?: number): this;
    /**
     * Hue Saturation Lightness
     * @param {number} h 0..1 (hue rotation compressed to normal 0 to 1 range where 1 represents 360deg)
     * @param {number} s 0..1
     * @param {number} l 0..1
     */
    setHSL(h: number, s: number, l: number): void;
    /**
     * Hue Chroma Luma
     * @param {number} h Hue
     * @param {number} c Chroma
     * @param {number} l Luma
     */
    setHCL(h: number, c: number, l: number): void;
    /**
     * NOTE: I'm not sure if the implementation is correct, based on wikipedia article
     * Hue Saturation Intensity
     * @param {number} h 0..1 (hue rotation compressed to normal 0 to 1 range where 1 represents 360deg)
     * @param {number} s 0..1
     * @param {number} i 0..1
     * @see https://en.wikipedia.org/wiki/HSL_and_HSV
     */
    setHSI(h: number, s: number, i: number): void;
    /**
     * Hue Saturation Value
     * @param {number} h 0..1
     * @param {number} s 0..1
     * @param {number} v 0..1
     */
    setHSV(h: number, s: number, v: number): void;
    /**
     *
     * @return {number}
     */
    computeLuminance(): number;
    getHSV(): {
        h: number;
        s: number;
        v: number;
    };
    /**
     * Encodes RGB to uint24
     * @returns {number}
     */
    toUint(): number;
    /**
     * Encodes RGBA to uint32
     * @returns {number}
     */
    toUint32(): number;
    /**
     *
     * @param {number} value
     */
    fromUint(value: number): void;
    /**
     * Returns color in CSS hex color format
     * @example #FF0000
     * @returns {string}
     */
    toHex(): string;
    /**
     *
     * @returns {string}
     */
    toCssRGBAString(): string;
    /**
     *
     * @param {Color} other
     */
    equals(other: Color): boolean;
    /**
     *
     * @param {Color} other
     */
    copy(other: Color): void;
    /**
     *
     * @returns {Color}
     */
    clone(): Color;
    /**
     *
     * @returns {number}
     */
    hash(): number;
    fromJSON({ r, g, b, a }: {
        r: any;
        g: any;
        b: any;
        a?: number;
    }): void;
    toJSON(): {
        r: number;
        g: number;
        b: number;
        a: number;
    };
    toString(): string;
    /**
     *
     * @param {number[]} [destination] where to write the output, if not provided a new array will be created
     * @param {number} [destination_offset]
     * @returns {number[]} [g,g,b,a], same object as input destination (if provided)
     */
    toArray(destination?: number[], destination_offset?: number): number[];
    /**
     * Can be either RGB or RGBA, in case of 3 element array, A(alpha) channel will be se to 1
     * @param {number[]|Float32Array} source
     * @param {number} [offset]
     * @returns {Color}
     */
    fromArray(source: number[] | Float32Array, offset?: number): Color;
    /**
     * @deprecated please use your own {@link BinaryClassSerializationAdapter}
     * @param {BinaryBuffer} buffer
     */
    toBinaryBuffer(buffer: BinaryBuffer): void;
    /**
     * @deprecated please use your own {@link BinaryClassSerializationAdapter}
     * @param {BinaryBuffer} buffer
     */
    fromBinaryBuffer(buffer: BinaryBuffer): void;
    /**
     * @param {string|number} str CSS-style string
     * @returns {void}
     */
    parse(str: string | number): void;
    /**
     *
     * @param {Color} a
     * @param {Color} b
     * @param {number} f
     * @returns {this}
     */
    lerpColors(a: Color, b: Color, f: number): this;
    /**
     * Multiply every component by a scalar value
     * @param {number} x
     * @returns {this}
     */
    multiplyScalar(x: number): this;
    /**
     * Component-wise vector multiplication
     * @param {Color} other
     * @returns {this}
     */
    multiply(other: Color): this;
    /**
     * @readonly
     * @type {boolean}
     */
    readonly isColor: boolean;
    [Symbol.iterator](): Generator<number, void, unknown>;
}
export namespace Color {
    let red: Readonly<Color>;
    let green: Readonly<Color>;
    let blue: Readonly<Color>;
    let yellow: Readonly<Color>;
    let cyan: Readonly<Color>;
    let magenta: Readonly<Color>;
    let white: Readonly<Color>;
    let black: Readonly<Color>;
    let transparent: Readonly<Color>;
}
import Signal from "../events/signal/Signal.js";
//# sourceMappingURL=Color.d.ts.map