/**
 * Copyright (c) 2018-2025 mol* contributors, licensed under MIT, See LICENSE file for more info.
 *
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 */
import { ColorTheme } from './color.js';
import { SizeTheme } from './size.js';
import { Structure } from '../mol-model/structure.js';
import { Volume } from '../mol-model/volume.js';
import { ParamDefinition as PD } from '../mol-util/param-definition.js';
import { Shape } from '../mol-model/shape.js';
import { CustomProperty } from '../mol-model-props/common/custom-property.js';
import { ColorType } from '../mol-geo/geometry/color-data.js';
import { Location } from '../mol-model/location.js';
export interface ThemeRegistryContext {
    colorThemeRegistry: ColorTheme.Registry;
    sizeThemeRegistry: SizeTheme.Registry;
}
export interface ThemeDataContext {
    [k: string]: any;
    structure?: Structure;
    volume?: Volume;
    shape?: Shape;
    /** Hint to request support for specific kinds of locations */
    locationKinds?: ReadonlyArray<Location['kind']>;
}
export { Theme };
interface Theme {
    color: ColorTheme<any, any>;
    size: SizeTheme<any>;
}
declare namespace Theme {
    type Props = {
        [k: string]: any;
    };
    export function create(ctx: ThemeRegistryContext, data: ThemeDataContext, props: Props, theme?: Theme): Theme;
    export function createEmpty(): Theme;
    export function ensureDependencies(ctx: CustomProperty.Context, theme: ThemeRegistryContext, data: ThemeDataContext, props: Props): Promise<void>;
    export function releaseDependencies(theme: ThemeRegistryContext, data: ThemeDataContext, props: Props): void;
    export {};
}
export interface ThemeProvider<T extends ColorTheme<P, G> | SizeTheme<P>, P extends PD.Params, Id extends string = string, G extends ColorType = ColorType> {
    readonly name: Id;
    readonly label: string;
    readonly category: string;
    readonly factory: (ctx: ThemeDataContext, props: PD.Values<P>) => T;
    readonly getParams: (ctx: ThemeDataContext) => P;
    readonly defaultValues: PD.Values<P>;
    readonly isApplicable: (ctx: ThemeDataContext) => boolean;
    readonly ensureCustomProperties?: {
        attach: (ctx: CustomProperty.Context, data: ThemeDataContext) => Promise<void>;
        detach: (data: ThemeDataContext) => void;
    };
}
export declare class ThemeRegistry<T extends ColorTheme<any, any> | SizeTheme<any>> {
    private emptyProvider;
    private _list;
    private _map;
    private _name;
    get default(): {
        name: string;
        provider: ThemeProvider<T, any>;
    };
    get list(): {
        name: string;
        provider: ThemeProvider<T, any>;
    }[];
    get types(): [string, string, string][];
    constructor(builtInThemes: {
        [k: string]: ThemeProvider<T, any>;
    }, emptyProvider: ThemeProvider<T, any>);
    private sort;
    add<P extends PD.Params>(provider: ThemeProvider<T, P>): void;
    remove(provider: ThemeProvider<T, any>): void;
    has(provider: ThemeProvider<T, any>): boolean;
    get<P extends PD.Params>(name: string): ThemeProvider<T, P>;
    getName(provider: ThemeProvider<T, any>): string;
    create(name: string, ctx: ThemeDataContext, props?: {}): T;
    getApplicableList(ctx: ThemeDataContext): {
        name: string;
        provider: ThemeProvider<T, any>;
    }[];
    getApplicableTypes(ctx: ThemeDataContext): [string, string, string][];
    clear(): void;
}