import { Node, ListenerSubscription } from "./node";
import { EventType, EventCallback, EventValueChangeCallback, IProperty } from "../interfaces";
import { Shade } from "./shade";
export interface PropertyOpts<T> {
    defaultValue?: T;
    getDefaultValue?: () => T | undefined;
}
export interface Category<T> {
    display: string;
    css: string;
    json: string;
    members: T[];
}
/**
 * A property of a generic type.
 * @category Utilities
 */
export declare class Property<T> extends Node implements IProperty {
    readonly required: boolean;
    protected value?: T;
    private opts;
    constructor(name: string, required: boolean, parent: Node, opts?: PropertyOpts<T>);
    isInitialized(): boolean;
    getValue(): T | undefined;
    setValue(newValue: T | undefined): void;
    sendValueChangeNotification(oldValue: any, newValue: any): void;
    getDefaultValue(): T | undefined;
    setListener(name: string, listener: EventCallback, eventTypes?: EventType[]): ListenerSubscription;
    setPropertyListener(name: string, callback: EventValueChangeCallback<T>): ListenerSubscription;
    serialize(): any;
    deserialize(obj: any): void;
    toJSON(): Object;
    protected getShadeRef(shade?: Shade): any;
    protected getShadeFromRef(ref: any): Shade | undefined;
    protected _addProperties(props: IProperty[]): void;
}
/**
 * Register a single listener for a group of properties and call the callback
 * when all of the properties have values and any of their values change.
 * @category Utilities
 */
export declare class PropertyGroupListener {
    private props;
    private cb;
    private or;
    private lname;
    private started;
    constructor(name: string, props: Property<any>[], cb: (pgl: PropertyGroupListener) => void, opts?: {
        or?: boolean;
    });
    start(): void;
    stop(): void;
    private callback;
    private allPropsHaveValues;
}
export declare class PropertyString extends Property<string> {
}
export declare class PropertyNumber extends Property<number> {
}
export declare class PropertyBoolean extends Property<boolean> {
}
export declare class PropertyPixel extends Property<number> {
}
export declare class PropertyTime extends Property<number> {
}
/**
 * A range of numeric values property.
 * @category Utilities
 */
export declare class PropertyRange extends Property<number> {
    min: number;
    max: number;
    constructor(name: string, min: number, max: number, required: boolean, parent: Node, opts?: PropertyOpts<number>);
    deserialize(obj: any): void;
    serialize(): any;
}
export declare class PropertySelectable<S, T> extends Property<T> {
    private sopts;
    private propertyGroupListener?;
    constructor(name: string, required: boolean, parent: Node, opts: PropertySelectableOpts<S, T>);
    setDefault(defaultValue: T): void;
    stop(): void;
    getSelectableValues(): S;
    setSelectableValues(s: S): void;
    getDefaultValue(): T | undefined;
    private sendSelectablesChangedNotification;
}
export declare class PropertyStringSelectable extends PropertySelectable<string[], string> {
}
export interface PropertySelectableOpts<S, T> extends PropertyOpts<T> {
    selectables?: S;
    getSelectables?: () => S;
    dependentProps?: Property<any>[];
}
export declare class PropertyNumberSelectable extends PropertySelectable<number[], number> {
    constructor(name: string, required: boolean, parent: Node, numbers: number[], defaultValue?: number);
}
export declare class PropertyPercentageSelectable extends PropertyNumberSelectable {
    constructor(name: string, required: boolean, parent: Node, percentages: number[], defaultPercentage: number);
}
export declare class PropertyPixelSelectable extends PropertySelectable<number[], number> {
    constructor(name: string, required: boolean, parent: Node, pixels: number[], defaultValue?: number);
}
export declare class PropertyIndexSelectable extends PropertyStringSelectable {
    private readonly none;
    private readonly prefix;
    private readonly inversePrefix;
    constructor(name: string, required: boolean, parent: Node, min: number, max: number, none: string, prefix: string, inversePrefix: string, defIdx?: number);
    toIndex(): number;
    private static indexToString;
    private static toStrings;
}
export interface CategoryAndIndex<T> {
    category: Category<T>;
    categoryIndex: number;
    memberIndex: number;
}
export declare class PropertyStringCategorySelectable extends PropertySelectable<Category<string>[], string> {
    constructor(name: string, required: boolean, parent: Node, opts: PropertySelectableOpts<Category<string>[], string>);
    getCategoryAndIndex(): CategoryAndIndex<string> | undefined;
}
export declare class PropertyShadowSelectable extends PropertyStringCategorySelectable {
    constructor(name: string, required: boolean, parent: Node, opts?: {
        defaultValue?: string;
    });
}
export declare class PropertyButtonText extends PropertyStringSelectable {
    constructor(name: string, required: boolean, node: Node);
}
export declare class PropertyBackgroundColorStyle extends PropertyStringSelectable {
    constructor(name: string, required: boolean, node: Node);
}
export declare const defaultPrimaryFont = "Open Sans";
export declare const defaultSecondaryFont = "Open Sans";
export declare class PropertyFontFamily extends PropertyStringSelectable {
    constructor(name: string, required: boolean, node: Node);
}
export declare class PropertyNumberRange extends PropertyNumber {
    min: number;
    max: number;
    constructor(name: string, required: boolean, node: Node, min: number, max: number, def: number);
    setValue(num: number): void;
}
export declare class PropertyPercentage extends PropertyNumberRange {
    constructor(name: string, required: boolean, parent: Node, defaultPercentage: number);
}
export declare class PropertyFontRange extends PropertyNumberRange {
}
export declare class PropertyPixelRange extends PropertyNumberRange {
}
export declare class PropertyColorShade extends PropertySelectable<Shade[][], Shade> {
    serialize(): any;
    deserialize(obj: any): void;
}
export declare class PropertyColorPair extends PropertySelectable<ColorPair[], ColorPair> {
    constructor(name: string, required: boolean, theme: Node, selectables: ColorPair[]);
    serialize(): any;
    deserialize(obj: any): void;
}
export declare class PropertyTitledShade extends PropertySelectable<TitledShade[], TitledShade> {
    serialize(): any;
    deserialize(obj: any): void;
}
export declare class ColorPair {
    title: string;
    readonly primary: Shade;
    readonly secondary: Shade;
    lighter: boolean;
    constructor(title: string, primary: Shade, secondary: Shade, lighter: boolean);
    deserialize(obj: any): void;
    serialize(): any;
}
export declare class TitledShade {
    readonly title: string;
    shade: Shade;
    constructor(title: string, shade: Shade);
    deserialize(obj: any): void;
    serialize(): any;
}