import { CursorProperty } from 'csstype';
import { EventEmitter } from 'eventemitter3';
import { Component, PureComponent } from 'react';
import * as React from 'react';
declare namespace interfaces {
    interface Newable<T> {
        new (...args: any[]): T;
    }
    interface TypeRegistry<T extends Newable<any>> {
        getConstructorById(id: string): T;
    }
    interface ViewRegistry {
        getViewComponentByModelType(id: string): StaticViewComponent<any>;
    }
    type VariableOptions<T> = {
        [K in keyof T]?: T[K];
    } & {
        label: string;
        responsive?: boolean;
        isEditable?(modelInstance: ModelInstance<any>): boolean;
    };
    interface VariableMetadata<T> {
        type: any;
        options: VariableOptions<T> | T;
        flags: Array<{
            flag: symbol;
            path?: string;
        }>;
        hasFlag(flagId: symbol, path?: string): boolean;
    }
    interface VariableTypeMetadata {
        code: string;
        label: string;
    }
    interface ModelMetadata {
        code: string;
        label: string;
        tags: string[];
        tools: ToolConnection[];
        variables: {
            [index: string]: VariableMetadata<any>;
        };
    }
    enum Breakpoint {
        sm = "sm",
        md = "md",
        lg = "lg",
        xl = "xl"
    }
    type BreakpointValues = {
        [B in Breakpoint]: number;
    };
    type ScalarValue = string | number | boolean | {
        [index: string]: any;
    };
    type Value = ScalarValue | Reference | Reference[] | null;
    type ResponsiveValue = {
        [B in Breakpoint]?: Value;
    };
    interface Variable {
        _value: Value | ResponsiveValue;
        editable?: boolean;
    }
    interface Reference {
        _ref: string;
    }
    type ModelId = string;
    interface ModelVariables {
        [index: string]: Variable | Reference | Reference[] | null;
    }
    type ModelParent = {
        id: ModelId;
        path: string;
    } | null;
    interface ModelData {
        id: string;
        parent: ModelParent;
        type: string;
        version: number;
        data: ModelVariables;
    }
    type VariableInstanceType = ModelInstance<any> | Array<ModelInstance<any>> | Value | ResponsiveValue;
    interface VariableInstance<T extends VariableInstanceType> {
        value: T | undefined;
        options: VariableOptions<T>;
        typeCode: string;
        isEditable: boolean;
        getCode(): string;
        setValue(value: ScalarValue): void;
        getVariableTypeMetadata(): VariableTypeMetadata;
        getElementComponent(): StaticElementComponent<T>;
        getFormElementComponent(): StaticElementComponent<T>;
        getModel(): ModelInstance<any>;
        requestValueChange(value: ScalarValue): void;
        hasFlag(flag: symbol, path?: string): boolean;
    }
    type ModelInstance<ModelType> = {
        [P in keyof ModelType]: ModelType[P];
    } & {
        isSelected: boolean;
        isFocused: boolean;
        isDeleted: boolean;
        isRepeatableChild: boolean;
        showGUIControls: boolean;
        modelToolConnections: ModelToolConnection[];
        recursiveToolConnections: ModelToolConnection[];
        toolConnections: ModelToolConnection[];
        actionToolSlots: ToolSlot[];
        modalToolSlots: ToolSlot[];
        selectedTool: string | undefined;
        getId(): string;
        getType(): string;
        getPage(): Page;
        getMetadata(): ModelMetadata;
        getVariableInstance(code: keyof ModelType): VariableInstance<any>;
        getModelViewComponent(): StaticViewComponent<ModelType>;
        isCarryingFlag(flag: symbol, path?: string): boolean;
    };
    interface PageData {
        id?: string;
        slug: string;
        title: string;
        data: {
            [index: string]: ModelData;
        };
    }
    type ResolvedMetadata<ModelType> = {
        [index in keyof ModelType]: {
            editable: boolean;
        };
    };
    interface ViewProps<ModelType> {
        model: ModelInstance<ModelType>;
    }
    type ViewComponent<ModelType> = PureComponent<ViewProps<ModelType>, any> | Component<ViewProps<ModelType>, any>;
    interface StaticViewComponent<ModelType> {
        id: string;
        toolBar?: ToolConnection[];
        new (props: ViewProps<ModelType>, context?: any): ViewComponent<ModelType>;
    }
    interface ElementProps<VT> {
        variable: VariableInstance<any>;
    }
    type ElementComponent<VT> = PureComponent<ElementProps<VT>, any> | Component<ElementProps<VT>, any>;
    interface StaticElementComponent<VT> {
        id: string;
        new (props: ElementProps<VT>, context?: any): ElementComponent<VT>;
    }
    interface ElementRegistry {
        getElementComponentByVariableType(id: string): StaticElementComponent<any>;
    }
    interface VariableTypeStatic<V extends Value> {
        new (model: ModelInstance<any>): VariableType<V>;
    }
    interface VariableType<V extends Value> {
        value: V | null;
    }
    interface ModelTypeStatic<ModelType> {
        new (page: Page): ModelType;
    }
    type AppEvent = 'modelAddedToPage' | 'modelRemovedFromPage' | 'pageModelMoved' | 'pageModelVariableSet';
    interface DragTransactionStatus {
        offsetX: number;
        offsetY: number;
        originX: number;
        originY: number;
        clientX: number;
        clientY: number;
        cursor?: CursorProperty;
    }
    interface DragTransaction {
        type: symbol;
        originX: number;
        originY: number;
    }
    interface App {
        breakpoints: BreakpointValues;
        currentBreakpoint: Breakpoint;
        currentPage: Page;
        editMode: boolean;
        elementRects: Map<string, ClientRect>;
        popoverState?: PopoverState;
        viewportScrollDepth: number;
        viewportGTScrollDepth: number;
        viewportScrollY: number;
        viewportWidth: number;
        viewportHeight: number;
        windowWidth: number;
        windowHeight: number;
        windowOffsetX: number;
        _window?: Window;
        _viewportElement?: HTMLElement;
        _rootElement?: HTMLElement;
        controller: EventEmitter<interfaces.AppEvent>;
        sidebarOpen: boolean;
        sidebarActiveTabIndex: number;
        isResizingAutomatically: boolean;
        isResizingManually: boolean;
        isResizing: boolean;
        isResizingElement: boolean;
        bindToWindow(_window: Window): App;
        bindToViewport(_viewport: HTMLElement): App;
        bindElement(element: HTMLElement, id?: string): string;
        openPopover(type: PopoverType, connection: PopoverConnection, position: PopoverPosition): void;
        closePopover(): void;
        openSettingsForm(): void;
        closeSettingsForm(): void;
        getPopoverState(): PopoverState | undefined;
        forceResponsivity(breakpoint: interfaces.Breakpoint): void;
        runWindowEvents(): void;
        getBreakpointSize(breakpoint: Breakpoint): number;
        getCurrentBreakpointSize(): number;
        getElementRect(id: string): ClientRect | null;
        getElementBoundRect(id: string): ClientRect | null;
        getViewportRect(): ClientRect;
        getViewportRootElement(): HTMLElement | null;
        startDragTransaction(dragTransactionType: symbol, event: React.DragEvent<any>): string;
        getDragTransactionStatus(transactionId: string): DragTransactionStatus | null;
        commitDragTransaction(transactionId: string): DragTransactionStatus | null;
        mapDimensionToViewport(dimension: DimensionType): DimensionType;
        mapDimensionToViewportCSS(dimension: DimensionType): string;
        scrollTo(posX: number, callback?: () => void): void;
        requestValueChange(variable: VariableInstance<any>, value: ScalarValue): void;
    }
    interface Page {
        id?: string | number;
        data: Map<string, interfaces.ModelData>;
        root: ModelInstance<any>;
        images: string[];
        selectedModel: string | null;
        focusedModel: string | null;
        focusedModels: string[];
        toolbarState: ToolbarPageState;
        getApp(): App;
        getModelInstanceById(id: string): ModelInstance<any>;
        addModel<ModelType>(type: string, data: interfaces.ModelVariables, parent: interfaces.ModelParent, insertIndex?: number): void;
        moveModel(id: string, parent: ModelParent, index?: number): void;
        removeModel(id: string): void;
        safelyRemoveModel(id: string): void;
        getModelData(id: string): ModelData;
        hasModelData(id: string): boolean;
        transformModel(id: string): ModelInstance<any>;
        getModelMetadata(type: string): ModelMetadata;
        getModelDepth(id: string): number;
        getModelRelationshipDepth(id: string, parentId: string): number;
        canModelBeMoved(id: string, targetId: string, variableCode: string): boolean;
        isModelRepeatableChild(id: string): boolean;
        isModelCarryingFlag(id: string, flag: symbol, path?: string): boolean;
        toggleTool(modelId: string, toolId: string): void;
        getSelectedToolId(modelId: string): string | undefined;
    }
    interface PopoverOrigin {
        horizontal: 'left' | 'middle' | 'right';
        vertical: 'top' | 'center' | 'bottom';
    }
    interface PopoverXYMountPosition {
        left: number;
        top: number;
    }
    interface PopoverPosition {
        anchorElement: HTMLElement;
        anchorOrigin: PopoverOrigin;
    }
    interface PopoverConnection {
        modelId: string;
    }
    interface PopoverAddModelConnection extends PopoverConnection {
        path: string;
        insertIndex: number;
        allowedTags?: string[];
    }
    type PopoverModelContextConnection = PopoverConnection;
    type PopoverModelPreviewConncetion = PopoverConnection;
    enum PopoverType {
        ADD_MODEL = 0,
        MODEL_CONTEXT = 1,
        MODEL_PREVIEW = 2
    }
    interface PopoverState {
        position: PopoverPosition;
        connection: PopoverConnection;
        open: boolean;
        type: PopoverType;
    }
    interface PopoverAddModelState extends PopoverState {
        connection: PopoverAddModelConnection;
        type: PopoverType.ADD_MODEL;
    }
    interface PopoverModelContextState extends PopoverState {
        connection: PopoverModelContextConnection;
        type: PopoverType.MODEL_CONTEXT;
    }
    interface PopoverModelPreviewState extends PopoverState {
        connection: PopoverModelPreviewConncetion;
        type: PopoverType.MODEL_PREVIEW;
    }
    enum ToolType {
        ACTION = "action",
        MODAL = "modal"
    }
    interface ToolConnection {
        id: string;
        options: ToolOptions;
        validate?: (model: ModelInstance<any>) => boolean;
    }
    interface ModelToolConnection {
        model: ModelInstance<any>;
        connection: ToolConnection;
    }
    interface ToolOptions {
        [index: string]: any;
    }
    interface ToolWrapperProps {
        model: ModelInstance<any>;
        options: ToolOptions;
        theme?: {
            [index: string]: string;
        };
    }
    type ToolWrapperComponent = Component<ToolWrapperProps>;
    interface StaticToolWrapperComponent {
        id: string;
        type: ToolType;
        new (props: ToolWrapperProps, context?: any): ToolWrapperComponent;
    }
    interface ToolProps extends ToolWrapperProps {
        active: boolean;
        buttonComponent: ToolButton;
    }
    type ToolComponent = Component<ToolProps>;
    interface StaticToolComponent<T extends ToolType> {
        id: string;
        type: T;
        new (props: ToolProps, context?: any): ToolComponent;
    }
    type ToolButton<Props = ToolButtonProps> = (props: Props) => React.ReactElement<any> | null;
    interface ToolButtonProps {
        icon: string;
    }
    interface ToolActionButtonProps extends ToolButtonProps {
        onClick(): void;
    }
    interface ToolModalButtonProps extends ToolButtonProps {
        onStateChanged(active: boolean): void;
    }
    type ToolbarPageState = Map<string, ToolbarModelState>;
    type ToolbarModelState = string;
    type ToolSlot = (theme: {
        [index: string]: any;
    }) => React.ReactElement<any>;
    interface ToolRegistry {
        getToolComponentByModelType(id: string): StaticToolWrapperComponent;
        getToolFromConnection(connection: ToolConnection): StaticToolWrapperComponent;
        getDefaultToolConnections(): ToolConnection[];
        getToolSlot(modelInstance: ModelInstance<any>, connection: ToolConnection): ToolSlot;
    }
    interface WindowEventOptions {
        boundByViewport: boolean;
    }
    type UnitType = '%' | 'vh' | 'vw' | 'px';
    interface DimensionType {
        size: number;
        unit: UnitType;
    }
    type UnitOptions = {
        [t in UnitType]?: {
            max: number;
            min: number;
            step: number;
        };
    };
}
export { interfaces };