import { Application } from '@pixi/app';
import { Application as Application_2 } from 'pixi.js';
import { Container } from '@pixi/display';
import { Container as Container_2 } from 'pixi.js';
import { DashLine } from 'pixi-dashed-line';
import { DashLineOptions } from 'pixi-dashed-line';
import { Graphics } from 'pixi.js';
import { IDestroyOptions } from 'pixi.js';
import { ILineStyleOptions } from '@pixi/graphics';
import { ILineStyleOptions as ILineStyleOptions_2 } from 'pixi.js';
import { InteractionEvent } from '@pixi/interaction';
import { InteractionEvent as InteractionEvent_2 } from 'pixi.js';
import { Matrix } from 'pixi.js';
import { ObservablePoint } from 'pixi.js';
import { Renderer } from 'pixi.js';
import { Text as Text_2 } from 'pixi.js';
import { TextStyle } from 'pixi.js';
import { Ticker } from 'pixi.js';
import { Viewport } from 'pixi-viewport';

/**
 * brush name enum
 *
 * @public
 */
export declare const enum BrushName {
    Pencil = "Pencil",
    Eraser = "Eraser",
    Highlighter = "Highlighter",
    Stroke = "Stroke",
    Rectangle = "Rectangle",
    Circle = "Circle",
    Triangle = "Triangle",
    RightAngleTriangle = "RightAngleTriangle",
    Parallelogram = "Parallelogram",
    RightAngleTrapezoid = "RightAngleTrapezoid",
    Trapezoid = "Trapezoid",
    SemiCircle = "SemiCircle",
    Cube = "Cube",
    Cuboid = "Cuboid",
    Sphere = "Sphere",
    Cylinder = "Cylinder",
    Cone = "Cone",
    Text = "Text"
}

/**
 * state of the brush in playerState
 *
 * @remarks
 *
 * describe current user's brush state,
 * like which brush are selected, what color or width are set.
 *
 * @public
 */
export declare interface BrushPluginState {
    brushName: BrushName;
    brushColor: number;
    brushWidth: 5;
    /**
     * apply dash line
     */
    dash?: boolean;
    /**
     * restrict shape bounding to square
     */
    restrict?: boolean;
    lineStyle: ILineStyleOptions;
}

/**
 * default brush state
 *
 * @public
 */
export declare const DefaultMondrianBrushOptions: BrushPluginState;

/**
 *
 * default mondrian settings
 *
 * @public
 */
export declare const DefaultMondrianSettings: IMondrianSettings;

declare interface IBoxBound {
    top: number;
    left: number;
    width: number;
    height: number;
}

declare type ICssStyle = {
    [key: string]: number | string | boolean;
};

export declare interface IMondrianActionData extends IMondrianCommonData {
    type: MondrianDataType.COMMAND;
    data: {
        subType: MondrianActionType;
        [key: string]: string | number | boolean | object;
    };
}

declare interface IMondrianCommonData {
    seq?: number;
    playerID?: string;
    extra?: {
        last: boolean;
    };
    local?: boolean;
}

export declare type IMondrianData = IMondrianInteractData | IMondrianStateData | IMondrianActionData;

export declare interface IMondrianDataClient {
    /**
     * start the data client
     *
     * @remarks will be called when the data manager start to init data client. Need to be override.
     */
    start(): void;
    /**
     * tell data manager data received and send data to data manager
     *
     * @remarks will be called by data client itself
     */
    receivedFromRemote: MondrianDataClientReceivedListener;
    /**
     * tell data manager data recovered and send data to data manager
     *
     * @remarks will be called by data client itself
     */
    recoveredFromRemote: MondrianDataClientRecoveredListener;
    /**
     *
     * called by data manager when new data had been created.
     *
     * @remarks need to be override
     *
     * @param datasToSend
     */
    sendToRemote(datasToSend: IMondrianData[]): void;
    /**
     *
     * @remarks should not be override or called in data client
     *
     * @internal
     *
     * @param listener
     */
    bindReceivedListener(listener: MondrianDataClientReceivedListener): void;
    /**
     *
     * @remarks should not be override or called in data client
     *
     * @internal
     *
     * @param listener
     */
    bindRecoveredListener(listener: MondrianDataClientRecoveredListener): void;
}

declare interface IMondrianDebugTimePair {
    s?: number;
    e?: number;
    valid: boolean;
    deltaMs?: number;
    msg?: string;
}

export declare interface IMondrianInteractData extends IMondrianCommonData {
    type: MondrianDataType.INTERACT;
    data: {
        subType: MondrianInteractType;
        x: number;
        y: number;
        code?: string;
        shiftKey?: boolean;
        altKey?: boolean;
        ctrlKey?: boolean;
        spaceKey?: boolean;
        value?: string;
        targetID?: number;
    };
}

declare interface IMondrianInteractor {
    onStateChange(states: IMondrianState): void;
    onDragStart(event: IMondrianMockInteractionEvent): void;
    onDragMove(event: IMondrianMockInteractionEvent): void;
    onDragEnd(event: IMondrianMockInteractionEvent): void;
    onUndo(event: unknown): void;
    onRedo(event: unknown): void;
    onClear(event: unknown): void;
    onKeyDown(event: unknown): void;
    onKeyUp(event: unknown): void;
    onClick(event: unknown): void;
    onInput(event: unknown): void;
    onFocus(event: unknown): void;
    onBlur(event: unknown): void;
}

declare interface IMondrianMockInteractionEvent extends InteractionEvent {
    mock?: boolean;
    mockX: number;
    mockY: number;
}

declare interface IMondrianPlayer {
    id: string;
    state: IMondrianPlayerState;
    consume(datas: IMondrianData[]): void;
}

declare interface IMondrianPlayerState {
    brush: BrushPluginState;
}

/**
 * Mondrian Settings
 *
 * @remarks
 *
 * main settings of Mondrian instance
 *
 * @public
 */
export declare interface IMondrianSettings {
    /**
     * mondrian container
     *
     * @remarks
     *
     * mondrian will create and put canvas in it.
     */
    container: HTMLElement | null;
    /**
     * is producer role enable
     *
     * @remarks
     *
     * if set `false`, client will only received and draw data from other clients.
     * but will not react to user interaction.
     */
    isProducer?: boolean;
    /**
     * resolution to use
     *
     * @remarks
     *
     * by default we use msaa
     *
     * @defaultValue 1
     */
    resolution?: number;
    /**
     * history size
     *
     * @remarks
     *
     * size of grahpic handler cache. If cache exceeded, grahpic handler will be texturized.
     * if viewport controls is on,
     * cache will not be texturized and has no limit(might have performance issue when drawing tons of things).
     *
     * @defaultValue 20
     */
    historySize?: number;
    autoStart?: boolean;
    chunkLimit?: number;
    channel?: string;
    disableCursor?: boolean;
    debug?: boolean;
    /**
     * enable viewport
     *
     * @remarks
     *
     * enable viewport controls like wheel, drag and pinch.
     */
    viewport?: boolean;
    /**
     * enable background of stage
     *
     * @defaultValue `false`
     */
    background?: boolean;
    /**
     * width of the world
     *
     * @remarks
     *
     * logic width, not pixel width
     *
     * @defaultValue 1280
     */
    worldWidth: number;
    /**
     * height of the world
     *
     * @remarks
     *
     * logic height, not pixel height
     *
     * @defaultValue 720
     */
    worldHeight: number;
    /**
     * determine if use builtin client instances
     *
     * @remarks use builtin ws client service
     *
     * @defaultValue false
     */
    useBuiltinClient: boolean;
    builtintClientUrl: string;
    /**
     * user defined client for data manager
     *
     * @remarks
     *
     * data manager only handle data flow inside mondrian
     * when you need to handle data flow between mondrian and out-of mondrian likes: sync draw data with server,
     * client will do the job.
     * client implements {@link IMondrianDataClient} interface, and extends base data client class {@link MondrianDataClient}, bind event to handle data in and do send data out.
     *
     * @example
     *
     * ```
     * export class CustomizedDataClient extends * MondrianDataClient {
     *   constructor() {
     *     super();
     *     // do something like create websocket * client instance
     *     console.log("my data client init");
     *   }
     *
     *   override start() {
     *     // do something like start websocket c lient
     *     console.log("my data client start");
     *
     *     // mock send data to let data manager * knows the last one of the first batch of * data recovered, and it is ready to tell * that recover process is finished, so * mondrian can do things likes removing * loading modal.
     *     this.receivedFromRemote([this.* generateLastData()]);
     *     this.recoveredFromRemote({ success: t rue, *size: 0 });
     *
     *     // mock received data synchronously
     *     setInterval(() => {
     *       // tell data manager to handle new * arrived data
     *       console.log("new data arrivied");
     *       this.receivedFromRemote([
     *         // data from remote
     *       ]);
     *     }, 3000);
     *   }
     *
     *   override sendToRemote(datasToSend: * IMondrianData[]) {
     *     // do something like emit data or do * request
     *     datasToSend.forEach((data) => {
     *       console.log("data to send", data);
     *     });
     *   }
     * }
     *
     * ```
     *
     */
    client?: IMondrianDataClient;
    /**
     * Set true to auto fit container to fullscreen size
     * and be automatically reponsive to window's resize event
     *
     * By default, user handle container's size. When container's size changed, resize api should be manually trigger to tell mondrian resize the pixi renderer.
     *
     * @defaultValue false
     */
    fullscreen?: boolean;
}

export declare interface IMondrianState {
    player: IMondrianPlayerState;
    [key: string]: string | number | boolean | object;
}

export declare interface IMondrianStateData extends IMondrianCommonData {
    type: MondrianDataType.SET_STATE;
    data: IMondrianState;
}

export declare interface IoClientSettings {
    channel: string;
}

declare type ITextInputBoxGeneratorFunc = (w: number, h: number, state: TextInputState) => Graphics;

declare type ITextInputBoxOption = {
    /**
     * The fill color of the box
     */
    fill?: number;
    /**
     * The border-radius
     */
    rounded?: number;
    /**
     * The style of the box's stroke
     */
    stroke?: {
        /**
         * the color of the stroke
         */
        color?: number;
        /**
         * the width of the stroke
         */
        width?: number;
        /**
         * the alpha of the stroke
         */
        alpha?: number;
    };
};

declare interface ITextInputBoxOptions {
    [TextInputState.DEFAULT]: ITextInputBoxOption;
    [TextInputState.FOCUSED]: ITextInputBoxOption;
    [TextInputState.DISABLED]: ITextInputBoxOption;
}

declare interface ITextInputOptions {
    input: ICssStyle;
    box: Partial<ITextInputBoxOptions> | ITextInputBoxGeneratorFunc;
}

/**
 * @public
 */
export declare class Mondrian extends MondrianModuleBase {
    /**
     * self's props
     */
    private _ID;
    /**
     * modules
     */
    private shared;
    private containerManager;
    private loading;
    private renderer;
    private playerManager;
    private eventProxier;
    private dataManager;
    private _settings;
    constructor(_settings: Partial<IMondrianSettings>);
    start(): Promise<boolean>;
    get ID(): string;
    get player(): MondrianProducer;
    get interaction(): MondrianEventProxier;
    get dm(): MondrianDataManager;
    get settings(): IMondrianSettings;
    get __debugPixiApp(): Application_2;
    get __debugShared(): MondrianShared;
    get containers(): MondrianContainerManager;
    showPannel(): void;
    hidePannel(): void;
    /**
     *
     * resize mondrian stage manually.
     *
     *
     * @public
     *
     */
    resize(): void;
    /**
     * reset viewport's postion and scale to container's center
     */
    fitCenter(): void;
}

export declare const enum MondrianActionType {
    UNDO = "ud",
    REDO = "rd",
    CLEAR = "cl",
    SYSTEM = "sy"
}

/**
 * builtin websocket based data client
 *
 * @remarks default websocket based data client, auto sync data from/to remote ws server.
 *
 */
export declare class MondrianBuiltinWsClient extends MondrianDataClient {
    private shared;
    private socket;
    /**
     * temp buffer zone stores temp real-item data before recover
     */
    private _tempBuffer;
    private _recovered;
    /**
     *
     * @param shared.settings.builtintClientUrl ws server url
     *
     * todo describe default ws data protocals
     *
     */
    constructor(shared: MondrianShared);
    sendToRemote(datas: IMondrianData[]): void;
    start(): void;
    forceClear(): void;
}

declare class MondrianConsumer extends MondrianPlayer {
    private renderer;
    private shared;
    private pluginManager;
    constructor(id: string, renderer: MondrianRenderer, shared: MondrianShared);
    consume(datas: IMondrianData[]): void;
    private dataXyToLeftTop;
}

declare class MondrianContainerManager extends MondrianModuleBase {
    private shared;
    /**
     * DOM container ref
     */
    private _$container;
    private _$panel?;
    constructor(shared: MondrianShared);
    start(): void;
    resize(): void;
    private initializeContainer;
    private initialzieDebugPanel;
    setCursorVisible(flag: boolean): void;
    get $container(): HTMLElement;
    get $panel(): HTMLDivElement | undefined;
    hidePannel(): void;
    showPannel(): void;
    createStatisticItem(name: string, description: string): void;
    getStatisticItem(name: string): Element | undefined;
    getStatisticValueItem(name: string): Element | undefined;
    printInPannel(name: string, data: string | number): void;
}

/**
 * base class of data client
 *
 * @remarks implements {@link IMondrianDataClient}. Do default binding job. Beding default empty data client, it implements empty in/out APIs.
 *
 * @public
 *
 */
export declare class MondrianDataClient {
    private _receivedlistener;
    private _recovredListener;
    /**
     *
     * called when DataManager is ready
     *
     * @public
     */
    start(): void;
    /**
     * called when client received data from removeListener
     *
     * @remarks will be defined and bind by DataManager and called in client by user
     *
     */
    get receivedFromRemote(): MondrianDataClientReceivedListener;
    /**
     * called when client recovered data from removeListener
     *
     * @remarks will be defined and bind by DataManager and called in client by user
     *
     */
    get recoveredFromRemote(): MondrianDataClientRecoveredListener;
    /**
     * called when DataManager need to send data to remote
     *
     * @remarks will be defined by user, and called by DataManager
     *
     * @public
     *
     * @param datasToSend
     * @returns
     */
    sendToRemote(datasToSend: IMondrianData[]): void;
    /**
     *
     * bind received listener
     *
     * @remarks should not be override or called outside mondrian
     *
     * @param listener
     */
    bindReceivedListener(listener: MondrianDataClientReceivedListener): void;
    /**
     *
     * bind received listener
     *
     * @remarks should not be override or called outside mondrian
     *
     * @param listener
     */
    bindRecoveredListener(listener: MondrianDataClientRecoveredListener): void;
    /**
     *
     * @returns
     */
    protected generateLastData(): IMondrianData;
}

/**
 * data received listener type
 */
export declare type MondrianDataClientReceivedListener = (datas: IMondrianData[], isRecover?: boolean) => void;

/**
 * data recovered listener type
 */
declare type MondrianDataClientRecoveredListener = (info: {
    success: boolean;
    size: number;
}) => void;

export declare class MondrianDataManager extends MondrianModuleBase {
    private playerManager;
    private renderer;
    private shared;
    sharedBuffer: MondrianSharedBuffer;
    client: IMondrianDataClient;
    private upStream;
    private downStream;
    private reader;
    private writer;
    private get consumers();
    constructor(playerManager: MondrianPlayerManager, renderer: MondrianRenderer, shared: MondrianShared);
    start(): Promise<unknown>;
    stop(): void;
    startRead(): Promise<void>;
    startWrite(): Promise<void>;
    private delayTime;
    private lastCount;
    dispatch(datas: IMondrianData[]): void;
    push(datas: IMondrianData[]): Promise<void>;
}

export declare const enum MondrianDataType {
    INTERACT = "i",
    SET_STATE = "s",
    COMMAND = "a"
}

/**
 * brush name list
 *
 * @remarks
 *
 * for client ui
 *
 * @public
 */
export declare const MondrianDefaultBrushPluginList: BrushName[];

declare class MondrianEventEmitter {
    listeners: {};
    addListener(eventName: any, fn: any): this;
    on(eventName: any, fn: any): this;
    once(eventName: any, fn: any): this;
    off(eventName: any, fn: any): this;
    removeListener(eventName: any, fn: any): this;
    emit(eventName: any, ...args: any[]): boolean;
    listenerCount(eventName: any): any;
    rawListeners(eventName: any): any;
}

declare class MondrianEventProxier extends MondrianEventEmitter {
    private playerManager;
    private renderer;
    private containerManager;
    private shared;
    private get interaction();
    private get interactor();
    private get stage();
    constructor(playerManager: MondrianPlayerManager, renderer: MondrianRenderer, containerManager: MondrianContainerManager, shared: MondrianShared);
    start(): void;
    stop(): void;
    startPixiEventWatch(): void;
    stopPixiEventWatch(): void;
    startSelfEventWatch(): void;
    stopSelfEventWatch(): void;
    destroy(): void;
    private onStateChange;
    private onUndo;
    private onRedo;
    private onClear;
    private onDragStart;
    private onDragMove;
    private onDragEnd;
    private keyDownMap;
    private onKeyDown;
    private onKeyUp;
    private onWheel;
    private onInput;
    private onFocus;
    private onBlur;
    private resizeEventHandler;
    resize(): void;
}

/**
 * mondrian events' names collection
 *
 * @public
 */
export declare class MondrianEvents {
    /**
     * trigger when recovered data has been consumed
     *
     * @public
     */
    static readonly EVENT_RECOVER_CONSUMED = "recover:consumed";
    /**
     *
     * trigger when recovered data has been received
     *
     * @public
     */
    static readonly EVNET_RECOVER_RECEIVED = "recover:received";
    /**
     * trigger when resize happens
     *
     * @public
     */
    static readonly EVENT_RESIZE = "resize";
}

declare class MondrianGraphicsHandler {
    private renderer;
    private layer;
    private shared;
    static DefaultOptions: MondrianGraphicsHandlerOptions;
    private _c?;
    private _g?;
    private _finished;
    private options;
    constructor(renderer: MondrianRenderer, layer: Container_2 | undefined, shared: MondrianShared, options?: MondrianGraphicsHandlerOptions);
    config(options: Partial<MondrianGraphicsHandlerOptions>): void;
    refresh(): void;
    start(): void;
    get c(): Container_2;
    get g(): Graphics;
    stop(): void;
    attach(): void;
    detach(): Container_2;
    afterDetach(): void;
    destroy(): void;
    get finished(): boolean;
    set lineStyle(style: ILineStyleOptions_2);
    get lineStyle(): ILineStyleOptions_2;
    /**
     * references to children graphics
     */
    children: {
        [name: string]: Graphics;
    };
    /**
     *  references to dashline instances
     */
    dashlines: {
        [name: string]: DashLine;
    };
    /**
     *  references to text instances
     */
    texts: {
        [name: string]: TextInput;
    };
    createDashLine(g: Graphics, options?: DashLineOptions): DashLine;
}

declare interface MondrianGraphicsHandlerOptions {
    canCacheAsBitmap?: boolean;
    /**
     * enable discrete graphics
     */
    enableDiscrete?: boolean;
    lineStyle: ILineStyleOptions_2;
}

export declare const enum MondrianInteractType {
    POINTER_DOWN = "pd",
    POINTER_MOVE = "pm",
    POINTER_UP = "pu",
    KEY_DOWN = "kd",
    KEY_UP = "ku",
    INPUT = "i",
    INPUT_ADD = "ia",
    FOCUS = "f",
    BLUR = "b"
}

declare class MondrianModuleBase extends MondrianEventEmitter {
    private _initialized;
    private _running;
    constructor();
    start(): void;
    stop(): void;
    get initialized(): boolean;
    get running(): boolean;
}

declare class MondrianPlayer implements IMondrianPlayer {
    private _id;
    private _state;
    consume(datas: IMondrianData[]): void;
    get id(): string;
    set id(id: string);
    get state(): IMondrianPlayerState;
    set state(state: IMondrianPlayerState);
}

declare class MondrianPlayerManager extends MondrianModuleBase {
    private shared;
    private _producer?;
    private _consumers;
    private dataManager;
    private renderer;
    constructor(shared: MondrianShared);
    injectDataManager(dataManager: MondrianDataManager): void;
    injectRenderer(renderer: MondrianRenderer): void;
    get producer(): MondrianProducer;
    get consumers(): Map<string, MondrianConsumer>;
    /**
     * create default producer and consumer
     */
    start(): void;
    stop(): void;
    createProducer(): void;
    createConsumer(id?: string): void;
    getConsumerByID(_id: string): void;
    /**
     * check if deps ready
     */
    private detect;
}

declare class MondrianProducer extends MondrianPlayer implements IMondrianInteractor {
    private dataManager;
    private renderer;
    private shared;
    private get root();
    constructor(id: string, dataManager: MondrianDataManager, renderer: MondrianRenderer, shared: MondrianShared);
    consume(datas: IMondrianData[]): void;
    onStateChange(states: IMondrianState): void;
    onDragStart(event: IMondrianMockInteractionEvent): void;
    onDragMove(event: IMondrianMockInteractionEvent): void;
    onDragEnd(event: IMondrianMockInteractionEvent): void;
    onUndo(_event: unknown): void;
    onRedo(_event: unknown): void;
    onClear(_event: unknown): void;
    onKeyDown(event: KeyboardEvent): void;
    onKeyUp(event: KeyboardEvent): void;
    onClick(_event: unknown): void;
    onInput(event: {
        value: string;
        targetID: number;
    }): void;
    onFocus(event: {
        targetID: number;
    }): void;
    onBlur(event: {
        targetID: number;
    }): void;
    private packEvent;
    private getXyFromEvent;
    private xyToCenter;
}

declare class MondrianRenderer extends MondrianModuleBase {
    private containerManager;
    private shared;
    private $canvas;
    /**
     * pixi's instances
     */
    private app;
    viewport: Viewport;
    rootLayer: Container;
    uiLayer: Container;
    private dynamicLayer;
    private staticLayer;
    private fixedTexture;
    private fixedSprite;
    private dynamicLevel;
    private dynamicBufferingCache;
    private dynamicCache;
    private dynamicCacheIndex;
    private trash;
    /**
     * pixi app instance
     */
    get pixiApp(): Application;
    /**
     * pixi app ticker
     */
    get ticker(): Ticker;
    /**
     * current viewport scale
     */
    get scale(): ObservablePoint<any> | {
        x: number;
        y: number;
    };
    /**
     * current bounding rect size of world
     */
    get worldRect(): {
        width: number;
        height: number;
    };
    private get $panel();
    constructor(containerManager: MondrianContainerManager, shared: MondrianShared);
    start(): void;
    /**
     * reset viewport position and scale to fit container's center
     */
    fitViewportToCenter(): void;
    stop(): void;
    private initializePIXIApplication;
    resize(): void;
    private initialPerfTool;
    /**
     * shift graphics handler out when reach dynamicLevel,
     *
     */
    private shiftGrapicsHandlersToStatic;
    startGraphicsHandler(options?: MondrianGraphicsHandlerOptions): MondrianGraphicsHandler;
    __debug_grahpic_draw: number;
    exchangeBufferingCache(handler: MondrianGraphicsHandler): void;
    stopGraphicsHandler(handler: MondrianGraphicsHandler): void;
    /**
     * these handler would not be moved to static layer
     * will be mark gc-able now.
     */
    checkAndCleanDiscardableDynamicCache(): void;
    forward(): void;
    backward(): void;
    /**
     * main loop
     * normal prioriry
     * @returns
     */
    private main;
    unfinishedCount: number;
    /**
     * gc loop
     * low priority
     */
    private gc;
    private markGc;
    lastPerfDt: number;
    textureMem: number;
    graphicsCount: number;
    private perf;
    private __debug_unfinishedHandlerCount;
    private __debug_checkUnfinishedHandler;
}

declare class MondrianShared extends MondrianModuleBase {
    private mondrian;
    constructor(mondrian: Mondrian);
    get MID(): string;
    get settings(): IMondrianSettings;
    private __debug_log_on_console;
    /**
     * for debug
     */
    logs: string[];
    log(msg: string): void;
    times: Map<string, IMondrianDebugTimePair>;
    /**
     * save time mark pairs for debugging.
     * @param mark
     */
    time(mark: string): void;
    printTimes(): void;
    logTextureMem(data: string): void;
    logGCount(data: number): void;
    logXY(x: number, y: number): void;
}

declare class MondrianSharedBuffer {
    private _buffer;
    get buffer(): IMondrianData[];
    append(datas: IMondrianData[]): void;
}

declare class TextInput extends Container_2 {
    inputID: number;
    private inputStyle;
    private boxGenerator?;
    private isMultiline;
    private boxCache;
    private previousBoxInfoSnapshot;
    private isDomAdded;
    private isDomVisible;
    private _placeholder;
    private placeholderColor;
    private selection;
    private restrictValue;
    private substituted;
    domInput: HTMLInputElement | HTMLTextAreaElement;
    private _disabled;
    private _maxLength;
    restrictRegex: any;
    _last_renderer: any;
    state: TextInputState;
    _resolution: any;
    _canvas_bounds: IBoxBound;
    _box: any;
    /**
     * text body in canvas
     */
    surrogate?: Text_2;
    /**
     * text hitbox in canvas
     */
    private surrogateHitbox?;
    /**
     * todo what for?
     */
    private surrogateMask?;
    private fontMetrics?;
    private textMetrics?;
    constructor(styles: ITextInputOptions);
    get substituteText(): boolean;
    set substituteText(substitute: boolean);
    get placeholder(): string;
    set placeholder(text: string);
    get disabled(): any;
    set disabled(disabled: any);
    get maxLength(): any;
    set maxLength(length: any);
    get restrict(): any;
    set restrict(regex: any);
    get text(): string;
    set text(text: string);
    get htmlInput(): HTMLInputElement | HTMLTextAreaElement;
    focus(): void;
    blur(): void;
    select(): void;
    setInputStyle(key: string, value: number | string | boolean): void;
    destroy(options?: boolean | IDestroyOptions | undefined): void;
    _createDOMInput(): void;
    _addListeners(): void;
    _onInputKeyDown: (e: Event) => void;
    _onInputInput: () => void;
    _onInputKeyUp: (e: Event) => void;
    _onFocused: () => void;
    _onBlurred: () => void;
    _onAdded: () => void;
    _onRemoved: () => void;
    _setState(state: TextInputState): void;
    render(renderer: Renderer): void;
    _renderInternal(renderer: Renderer): void;
    _update(): void;
    _updateBox(): void;
    _updateSubstitution(): void;
    _updateDOMInput(): void;
    _applyRestriction(): void;
    _needsUpdate(): boolean;
    _needsNewBoxCache(): boolean;
    _createSurrogate(): void;
    _updateSurrogate(): void;
    _updateSurrogateHitbox(bounds: DOMRect): void;
    _updateSurrogateMask(bounds: DOMRect, padding: number[]): void;
    _destroySurrogate(): void;
    _onSurrogateFocus: (e: InteractionEvent_2) => void;
    _ensureFocus(): void;
    _deriveSurrogateStyle(): TextStyle;
    _deriveSurrogatePadding(): number[];
    _deriveSurrogateText(): string;
    _updateFontMetrics(): void;
    _buildBoxCache(): void;
    _destroyBoxCache(): void;
    _hasFocus(): boolean;
    _setDOMInputVisible(visible: boolean): void;
    _getCanvasBounds(): {
        top: any;
        left: any;
        width: any;
        height: any;
    };
    _getDOMInputBounds(): DOMRect;
    _getDOMRelativeWorldTransform(): Matrix;
    _pixiMatrixToCSS(m: Matrix): string;
    _comparePixiMatrices(m1?: Matrix, m2?: Matrix): boolean;
    _compareClientRects(r1?: IBoxBound, r2?: IBoxBound): boolean;
}

declare enum TextInputState {
    DEFAULT = "default",
    FOCUSED = "focused",
    DISABLED = "disabled"
}

export { }