interface DecoratorFactory<T> {
    (t: T): T;
}
/** A Component class constructor (supports abstract classes) */
export type ComponentConstructor<T extends Component = Component> = (abstract new (config?: any) => T) & {
    isComponentType: true;
    prototype: T;
};
/** Extract the config type from a Component class constructor */
export type ComponentConfigType<T> = T extends abstract new (config?: infer C) => any ? C & {
    isComponentType?: never;
} : unknown;
/** Extract the instance type from a Component class constructor */
export type ComponentInstanceType<T> = T extends abstract new (config?: any) => infer I ? I : Component;
/**
 * Type representing any valid input to Component.create that will produce an instance of T.
 *
 * Accepts:
 * - An instance of T (pass-through)
 * - A constructor for T or any subtype
 * - A config object for T (when T has a known config type)
 * - A config object with `type` or `$type` property specifying the constructor
 *
 * @example
 * // In a Chart widget config:
 * interface ChartConfig {
 *    xAxis?: Creatable<Axis>;  // Accepts NumericAxis, CategoryAxis, etc.
 *    yAxis?: Creatable<Axis>;
 * }
 *
 * // Usage:
 * <Chart xAxis={NumericAxis} />  // Just the type
 * <Chart xAxis={{ type: NumericAxis, min: 0, max: 100 }} />  // Config with type
 * <Chart xAxis={new NumericAxis({ min: 0 })} />  // Instance
 */
type SubclassConstructor<TBaseCtor extends ComponentConstructor> = ComponentConstructor<ComponentInstanceType<TBaseCtor>>;
type ResolveConfigType<TBaseCtor extends ComponentConstructor, TSubCtor extends ComponentConstructor> = 0 extends 1 & ComponentConfigType<TSubCtor> ? ComponentConfigType<TBaseCtor> : ComponentConfigType<TSubCtor>;
type ConfigWithType<TBaseCtor extends ComponentConstructor, TSubCtor extends SubclassConstructor<TBaseCtor>> = {
    type: TSubCtor;
} & ResolveConfigType<TBaseCtor, TSubCtor> & (0 extends 1 & ComponentConfigType<TSubCtor> ? {
    [key: string]: unknown;
} : {});
type ConfigWith$Type<TBaseCtor extends ComponentConstructor, TSubCtor extends SubclassConstructor<TBaseCtor>> = {
    $type: TSubCtor;
} & ResolveConfigType<TBaseCtor, TSubCtor> & (0 extends 1 & ComponentConfigType<TSubCtor> ? {
    [key: string]: unknown;
} : {});
export type CreateConfig<TBaseCtor extends ComponentConstructor, TSubCtor extends SubclassConstructor<TBaseCtor> = SubclassConstructor<TBaseCtor>> = TSubCtor | ConfigWithType<TBaseCtor, TSubCtor> | ConfigWith$Type<TBaseCtor, TSubCtor>;
export type Create<TCtor extends ComponentConstructor> = ComponentInstanceType<TCtor> | CreateConfig<TCtor>;
/**
 * Type-checks a CreateConfig object based on its `type` or `$type` property.
 * This is a compile-time helper that returns the input unchanged at runtime.
 * Uses `const` type parameter (TypeScript 5.0+) to enable excess property checking.
 *
 * @example
 * // With type property
 * const axisConfig = validateConfig({ type: NumericAxis, min: 0, max: 100 });
 *
 * // With $type property
 * const selectionConfig = validateConfig({ $type: KeySelection, bind: "selection" });
 */
export declare function validateConfig<const TCtor extends ComponentConstructor>(config: ({
    type: TCtor;
    $type?: never;
} & ComponentConfigType<TCtor>) | ({
    $type: TCtor;
    type?: never;
} & ComponentConfigType<TCtor>)): any;
export declare class Component {
    static namespace: string;
    static isComponentType: true;
    static autoInit: boolean;
    static factory: (alias: string, config?: any, more?: any) => Component;
    isComponent: boolean;
    constructor(config?: any);
    init(): void;
    /**
     *
     * @param alias
     * @param type
     */
    static alias<T>(alias: string, type: T): void;
    static alias<T>(alias: string): DecoratorFactory<T>;
    /**
     * Creates a component instance from various input types.
     *
     * Supported signatures:
     * - Pass-through: If input is already a component instance, returns it unchanged
     * - Array: Maps over array elements, creating components for each
     * - Class type: Creates instance of the specified class with config
     * - Config with type/$type: Creates instance of the type specified in config
     * - String alias: Looks up registered alias and creates that type
     * - Plain config: Creates instance of the class `create` was called on
     *
     * @example
     * // Pass-through
     * const btn = new Button();
     * Button.create(btn) // returns btn as Button
     *
     * // Class type with config
     * Button.create(Button, { text: "Click" }) // returns Button
     *
     * // Config with type property
     * Widget.create({ type: Button, text: "Click" }) // returns Button
     *
     * // Plain config on specific class
     * Button.create({ text: "Click" }) // returns Button with ButtonConfig typing
     */
    static create<T extends Component>(instance: T, unused?: any): T;
    static create<T extends ({
        type: ComponentConstructor;
        $type?: never;
    } | {
        $type: ComponentConstructor;
        type?: never;
    })[]>(configs: [...T], more?: Record<string, any>): {
        [K in keyof T]: T[K] extends {
            type: ComponentConstructor<infer U>;
        } ? U : T[K] extends {
            $type: ComponentConstructor<infer U>;
        } ? U : Component;
    };
    static create<TCtor extends ComponentConstructor, T extends Component = ComponentInstanceType<TCtor>>(config: ({
        type: TCtor;
        $type?: never;
        isComponentType?: never;
    } | {
        $type: TCtor;
        type?: never;
        isComponentType?: never;
    }) & Partial<ComponentConfigType<ComponentConstructor<T>>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
    static create<TCtor extends ComponentConstructor, T extends Component = ComponentInstanceType<TCtor>>(type: TCtor, configs: ComponentConfigType<ComponentConstructor<T>>[], more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T[];
    static create<TCtor extends ComponentConstructor, T extends Component = ComponentInstanceType<TCtor>>(type: TCtor, config?: ComponentConfigType<ComponentConstructor<T>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
    static create<T extends Component>(this: {
        prototype: T;
        isComponentType: true;
    }, configs: ComponentConfigType<ComponentConstructor<T>>[], more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T[];
    static create<T extends Component>(this: {
        prototype: T;
        isComponentType: true;
    }, config: ComponentConfigType<ComponentConstructor<T>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
    static create<T extends Component>(this: {
        prototype: T;
        isComponentType: true;
    }, alias: string, config?: ComponentConfigType<ComponentConstructor<T>>, more?: Partial<ComponentConfigType<ComponentConstructor<T>>>): T;
}
export declare function createComponentFactory(factory: any, jsxDriver: any, meta?: any): any;
export declare function isComponentFactory(factory: any): boolean;
export {};
//# sourceMappingURL=Component.d.ts.map