/**
 * Copyright (c) 2018-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
 *
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 */
import { Color } from '../mol-util/color';
import { Location } from '../mol-model/location';
import { ColorType, ColorTypeDirect, ColorTypeGrid, ColorTypeLocation } from '../mol-geo/geometry/color-data';
import { ParamDefinition as PD } from '../mol-util/param-definition';
import { ThemeDataContext, ThemeRegistry, ThemeProvider } from './theme';
import { ScaleLegend, TableLegend } from '../mol-util/legend';
import { Texture, TextureFilter } from '../mol-gl/webgl/texture';
import { Vec3, Vec4 } from '../mol-math/linear-algebra';
export declare type LocationColor = (location: Location, isSecondary: boolean) => Color;
export interface ColorVolume {
    colors: Texture;
    dimension: Vec3;
    transform: Vec4;
}
export { ColorTheme };
declare type ColorThemeShared<P extends PD.Params, G extends ColorType> = {
    readonly factory: ColorTheme.Factory<P, G>;
    readonly props: Readonly<PD.Values<P>>;
    /**
     * if palette is defined, 24bit RGB color value normalized to interval [0, 1]
     * is used as index to the colors
     */
    readonly palette?: Readonly<ColorTheme.Palette>;
    readonly preferSmoothing?: boolean;
    readonly contextHash?: number;
    readonly description?: string;
    readonly legend?: Readonly<ScaleLegend | TableLegend>;
};
declare type ColorThemeLocation<P extends PD.Params> = {
    readonly granularity: ColorTypeLocation;
    readonly color: LocationColor;
} & ColorThemeShared<P, ColorTypeLocation>;
declare type ColorThemeGrid<P extends PD.Params> = {
    readonly granularity: ColorTypeGrid;
    readonly grid: ColorVolume;
} & ColorThemeShared<P, ColorTypeGrid>;
declare type ColorThemeDirect<P extends PD.Params> = {
    readonly granularity: ColorTypeDirect;
} & ColorThemeShared<P, ColorTypeDirect>;
declare type ColorTheme<P extends PD.Params, G extends ColorType = ColorTypeLocation> = G extends ColorTypeLocation ? ColorThemeLocation<P> : G extends ColorTypeGrid ? ColorThemeGrid<P> : G extends ColorTypeDirect ? ColorThemeDirect<P> : never;
declare namespace ColorTheme {
    export const enum Category {
        Atom = "Atom Property",
        Chain = "Chain Property",
        Residue = "Residue Property",
        Symmetry = "Symmetry",
        Validation = "Validation",
        Misc = "Miscellaneous"
    }
    export interface Palette {
        filter?: TextureFilter;
        colors: Color[];
    }
    export const PaletteScale: number;
    export type Props = {
        [k: string]: any;
    };
    export type Factory<P extends PD.Params, G extends ColorType> = (ctx: ThemeDataContext, props: PD.Values<P>) => ColorTheme<P, G>;
    export const EmptyFactory: () => ColorThemeLocation<{}>;
    export const Empty: ColorTheme<{}>;
    export function areEqual(themeA: ColorTheme<any, any>, themeB: ColorTheme<any, any>): boolean;
    export interface Provider<P extends PD.Params = any, Id extends string = string, G extends ColorType = ColorType> extends ThemeProvider<ColorTheme<P, G>, P, Id, G> {
    }
    export const EmptyProvider: Provider<{}>;
    export type Registry = ThemeRegistry<ColorTheme<any, any>>;
    export function createRegistry(): ThemeRegistry<ColorThemeLocation<{}> | ColorThemeDirect<{}> | ColorThemeGrid<{}>>;
    export const BuiltIn: {
        'atom-id': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "atom-id", ColorType>;
        'carbohydrate-symbol': Provider<{}, "carbohydrate-symbol", ColorType>;
        'chain-id': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
            asymId: PD.Select<"label" | "auth">;
        }, "chain-id", ColorType>;
        'element-index': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "element-index", ColorType>;
        'element-symbol': Provider<{
            carbonColor: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "element-symbol"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
                asymId: "label" | "auth";
            }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "operator-name"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "entity-id"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "entity-source"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "model-index"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "structure-index">>;
            saturation: PD.Numeric;
            lightness: PD.Numeric;
            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
                H: Color;
                D: Color;
                T: Color;
                HE: Color;
                LI: Color;
                BE: Color;
                B: Color;
                C: Color;
                N: Color;
                O: Color;
                F: Color;
                NE: Color;
                NA: Color;
                MG: Color;
                AL: Color;
                SI: Color;
                P: Color;
                S: Color;
                CL: Color;
                AR: Color;
                K: Color;
                CA: Color;
                SC: Color;
                TI: Color;
                V: Color;
                CR: Color;
                MN: Color;
                FE: Color;
                CO: Color;
                NI: Color;
                CU: Color;
                ZN: Color;
                GA: Color;
                GE: Color;
                AS: Color;
                SE: Color;
                BR: Color;
                KR: Color;
                RB: Color;
                SR: Color;
                Y: Color;
                ZR: Color;
                NB: Color;
                MO: Color;
                TC: Color;
                RU: Color;
                RH: Color;
                PD: Color;
                AG: Color;
                CD: Color;
                IN: Color;
                SN: Color;
                SB: Color;
                TE: Color;
                I: Color;
                XE: Color;
                CS: Color;
                BA: Color;
                LA: Color;
                CE: Color;
                PR: Color;
                ND: Color;
                PM: Color;
                SM: Color;
                EU: Color;
                GD: Color;
                TB: Color;
                DY: Color;
                HO: Color;
                ER: Color;
                TM: Color;
                YB: Color;
                LU: Color;
                HF: Color;
                TA: Color;
                W: Color;
                RE: Color;
                OS: Color;
                IR: Color;
                PT: Color;
                AU: Color;
                HG: Color;
                TL: Color;
                PB: Color;
                BI: Color;
                PO: Color;
                AT: Color;
                RN: Color;
                FR: Color;
                RA: Color;
                AC: Color;
                TH: Color;
                PA: Color;
                U: Color;
                NP: Color;
                PU: Color;
                AM: Color;
                CM: Color;
                BK: Color;
                CF: Color;
                ES: Color;
                FM: Color;
                MD: Color;
                NO: Color;
                LR: Color;
                RF: Color;
                DB: Color;
                SG: Color;
                BH: Color;
                HS: Color;
                MT: Color;
                DS: Color;
                RG: Color;
                CN: Color;
                UUT: Color;
                FL: Color;
                UUP: Color;
                LV: Color;
                UUH: Color;
            }>, "custom">>;
        }, "element-symbol", ColorType>;
        'entity-id': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "entity-id", ColorType>;
        'entity-source': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "entity-source", ColorType>;
        hydrophobicity: Provider<{
            list: PD.ColorList;
            scale: PD.Select<"DGwif" | "DGwoct" | "Oct-IF">;
        }, "hydrophobicity", ColorType>;
        illustrative: Provider<{
            style: PD.Mapped<PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
                asymId: "label" | "auth";
            }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "entity-id"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "entity-source"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "model-index"> | PD.NamedParams<PD.Normalize<{
                palette: PD.NamedParams<PD.Normalize<{
                    maxCount: any;
                    hue: any;
                    chroma: any;
                    luminance: any;
                    clusteringStepCount: any;
                    minSampleCount: any;
                }>, "generate"> | PD.NamedParams<PD.Normalize<{
                    list: any;
                }>, "colors">;
            }>, "structure-index"> | PD.NamedParams<PD.Normalize<{
                value: Color;
            }>, "uniform"> | PD.NamedParams<PD.Normalize<{
                saturation: number;
                lightness: number;
                colors: PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
                    water: any;
                    ion: any;
                    protein: any;
                    RNA: any;
                    DNA: any;
                    PNA: any;
                    saccharide: any;
                }>, "custom">;
            }>, "molecule-type">>;
            carbonLightness: PD.Numeric;
        }, "illustrative", ColorType>;
        'model-index': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "model-index", ColorType>;
        'molecule-type': Provider<{
            saturation: PD.Numeric;
            lightness: PD.Numeric;
            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
                water: Color;
                ion: Color;
                protein: Color;
                RNA: Color;
                DNA: Color;
                PNA: Color;
                saccharide: Color;
            }>, "custom">>;
        }, "molecule-type", ColorType>;
        occupancy: Provider<{
            domain: PD.Interval;
            list: PD.ColorList;
        }, "occupancy", ColorType>;
        'operator-hkl': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "operator-hkl", ColorType>;
        'operator-name': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "operator-name", ColorType>;
        'partial-charge': Provider<{
            domain: PD.Interval;
            list: PD.ColorList;
        }, "partial-charge", ColorType>;
        'polymer-id': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "polymer-id", ColorType>;
        'polymer-index': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "polymer-index", ColorType>;
        'residue-name': Provider<{
            saturation: PD.Numeric;
            lightness: PD.Numeric;
            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
                ALA: Color;
                ARG: Color;
                ASN: Color;
                ASP: Color;
                CYS: Color;
                GLN: Color;
                GLU: Color;
                GLY: Color;
                HIS: Color;
                ILE: Color;
                LEU: Color;
                LYS: Color;
                MET: Color;
                PHE: Color;
                PRO: Color;
                SER: Color;
                THR: Color;
                TRP: Color;
                TYR: Color;
                VAL: Color;
                A: Color;
                G: Color;
                I: Color;
                C: Color;
                T: Color;
                U: Color;
                DA: Color;
                DG: Color;
                DI: Color;
                DC: Color;
                DT: Color;
                DU: Color;
                APN: Color;
                GPN: Color;
                CPN: Color;
                TPN: Color;
            }>, "custom">>;
        }, "residue-name", ColorType>;
        'secondary-structure': Provider<{
            saturation: PD.Numeric;
            lightness: PD.Numeric;
            colors: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "default"> | PD.NamedParams<PD.Normalize<{
                alphaHelix: Color;
                threeTenHelix: Color;
                piHelix: Color;
                betaTurn: Color;
                betaStrand: Color;
                coil: Color;
                bend: Color;
                turn: Color;
                dna: Color;
                rna: Color;
                carbohydrate: Color;
            }>, "custom">>;
        }, "secondary-structure", ColorType>;
        'sequence-id': Provider<{
            list: PD.ColorList;
        }, "sequence-id", ColorType>;
        'shape-group': Provider<{}, "shape-group", ColorType>;
        'structure-index': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "structure-index", ColorType>;
        'trajectory-index': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "trajectory-index", ColorType>;
        uncertainty: Provider<{
            domain: PD.Interval;
            list: PD.ColorList;
        }, "uncertainty", ColorType>;
        'unit-index': Provider<{
            palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
                maxCount: number;
                hue: [number, number];
                chroma: [number, number];
                luminance: [number, number];
                clusteringStepCount: number;
                minSampleCount: number;
            }>, "generate"> | PD.NamedParams<PD.Normalize<{
                list: {
                    kind: "set" | "interpolate";
                    colors: import("../mol-util/color/color").ColorListEntry[];
                };
            }>, "colors">>;
        }, "unit-index", ColorType>;
        uniform: Provider<{
            value: PD.Color;
        }, "uniform", ColorType>;
        'volume-value': Provider<{
            colorList: PD.ColorList;
        }, "volume-value", ColorType>;
    };
    type _BuiltIn = typeof BuiltIn;
    export type BuiltIn = keyof _BuiltIn;
    export type ParamValues<C extends ColorTheme.Provider<any>> = C extends ColorTheme.Provider<infer P> ? PD.Values<P> : never;
    export type BuiltInParams<T extends BuiltIn> = Partial<ParamValues<_BuiltIn[T]>>;
    export {};
}
export declare function ColorThemeProvider<P extends PD.Params, Id extends string>(p: ColorTheme.Provider<P, Id>): ColorTheme.Provider<P, Id>;