import * as React from "react";
import { LoadDataParams, EmbeddableType, NativeType, Dataset, Measure, Dimension, Granularity, Time, TimeRange, DimensionOrMeasure, DimensionType, MeasureType, DimensionOrMeasureType, DefaultNativeType } from "@embeddable.com/core";
declare global {
    interface Window {
        __EMBEDDABLE_DEVTOOLS__?: {
            notifyPropsUpdated: (componentId: string, componentMeta: EmbeddedComponentMeta, oldProps: any, newProps: any) => void;
            notifyDataLoaded: (componentId: string, componentMeta: EmbeddedComponentMeta, result: LoadDataResultEvent) => void;
            notifyVariableUpdated: (componentId: string, componentMeta: EmbeddedComponentMeta, event: ReloadDatasetEvent, dataLoaders: Record<string, LoadDataParams>) => void;
        };
    }
}
export type WrapperProps = {
    propsUpdateListener: HTMLElement;
    componentId: string;
    clientContext: any;
    embeddableTheme: any;
};
export type Config<Meta extends MetaWithOptionalEvents, Props, EmbeddableState> = {
    props?: (ownProps: Inputs<Meta>, embeddableState: [
        EmbeddableState,
        React.Dispatch<React.SetStateAction<EmbeddableState>>
    ], clientContext: any) => Props;
    events?: Record<string, EmbeddableEventHandler>;
};
export type EmbeddableEventHandler = (value: any) => any;
type ReloadDatasetEvent = {
    datasetId: string;
};
type LoadDataResultEvent = {
    isSuccess: boolean;
    componentId: string;
    propertyName: string;
    data?: any[];
    error?: string;
    total?: number;
};
type InputBase = {
    name: string;
    label: string;
    description?: string;
    defaultValue?: any;
    required?: boolean;
    category?: string;
};
type BasicInput = InputBase & {
    type: Exclude<EmbeddableType | NativeType, "dimension" | "measure" | "dimensionOrMeasure">;
    array?: boolean;
    config?: Record<string, any>;
};
type DimensionOrMeasureConfigBase = {
    dataset: string;
    [key: string]: any;
};
type DimensionConfig = DimensionOrMeasureConfigBase & {
    hideGranularity?: boolean;
};
type SubInput<T> = InputBase & {
    type: EmbeddableType | DefaultNativeType;
    supportedTypes?: T[];
};
type SingleDimensionInput = InputBase & {
    type: "dimension";
    array?: false;
    config: DimensionConfig;
    inputs?: SubInput<DimensionType>[];
};
type SingleMeasureInput = InputBase & {
    type: "measure";
    array?: false;
    config: DimensionOrMeasureConfigBase;
    inputs?: SubInput<MeasureType>[];
};
type SingleDimensionOrMeasureInput = InputBase & {
    type: "dimensionOrMeasure";
    array?: false;
    config: DimensionOrMeasureConfigBase;
    inputs?: SubInput<DimensionOrMeasureType>[];
};
type ArrayDimensionInput = InputBase & {
    type: "dimension";
    array: true;
    config: DimensionConfig;
    inputs?: SubInput<DimensionType>[];
};
type ArrayMeasureInput = InputBase & {
    type: "measure";
    array: true;
    config: DimensionOrMeasureConfigBase;
    inputs?: SubInput<MeasureType>[];
};
type ArrayDimensionOrMeasureInput = InputBase & {
    type: "dimensionOrMeasure";
    array: true;
    config: DimensionOrMeasureConfigBase;
    inputs?: SubInput<DimensionOrMeasureType>[];
};
export type ComponentMetaInput = BasicInput | SingleDimensionInput | SingleMeasureInput | SingleDimensionOrMeasureInput | ArrayDimensionInput | ArrayMeasureInput | ArrayDimensionOrMeasureInput;
export type EmbeddedComponentMeta = {
    name: string;
    label: string;
    description?: string;
    category?: string;
    classNames?: string[];
    defaultWidth?: number;
    defaultHeight?: number;
    inputs?: ComponentMetaInput[];
    events?: {
        name: string;
        label: string;
        properties?: {
            name: string;
            type: EmbeddableType | NativeType;
            array?: boolean;
            label?: string;
        }[];
    }[];
    variables?: {
        name: string;
        type: EmbeddableType | NativeType;
        array?: boolean;
        defaultValue?: unknown;
        inputs?: string[];
        events?: {
            name: string;
            property: string;
        }[];
    }[];
};
interface EmbeddableTypeMappings {
    dataset: Dataset;
    measure: Measure;
    dimension: Dimension;
    granularity: Granularity;
    string: string;
    number: number;
    boolean: boolean;
    time: Time;
    timeRange: TimeRange;
    dimensionOrMeasure: DimensionOrMeasure;
}
type MapInputType<Type extends EmbeddableType | NativeType> = Type extends EmbeddableType ? unknown : EmbeddableTypeMappings[Extract<Type, keyof EmbeddableTypeMappings>];
type MapInputs<Meta extends MetaWithOptionalEvents> = {
    [Input in Meta["inputs"][number] as Input["name"]]: Input extends {
        array: true;
    } ? MapInputType<Input["type"]>[] : MapInputType<Input["type"]>;
};
type EventItem = NonNullable<EmbeddedComponentMeta["events"]>[number];
type MapEventHandlers<Meta extends {
    events?: EmbeddedComponentMeta["events"];
}> = Meta["events"] extends ReadonlyArray<EventItem> ? {
    [K in Meta["events"][number]["name"]]: () => void;
} : {};
export type MetaWithOptionalEvents = Required<Pick<EmbeddedComponentMeta, "inputs">> & Partial<Pick<EmbeddedComponentMeta, "events">>;
export type Inputs<Meta extends MetaWithOptionalEvents> = MapInputs<Meta> & MapEventHandlers<Meta>;
export declare function defineComponent<Props, Meta extends MetaWithOptionalEvents, EmbeddableState extends object = {}>(InnerComponent: React.ComponentType<Props>, meta: EmbeddedComponentMeta, config?: Config<Meta, Props, EmbeddableState>): {
    ({ propsUpdateListener, clientContext, embeddableTheme, ...props }: WrapperProps): React.JSX.Element;
    displayName: string;
};
export {};