import type { ReactiveController, ReactiveControllerHost } from 'lit';
import type { ValuesOf } from '../../Types/ValuesOf';
import type { ContainerResizeMode } from '../Types/ContainerResizeMode';
import type { ResizeDirection } from '../Types/ResizeDirection';
export type ResizeCallback = (params: IResizeCallbackParams) => unknown;
export type ResizeCancelCallback = (state: IResizeState) => unknown;
export type ResizeGhostFactory = () => HTMLElement;
export interface IResizeState {
    initial: DOMRect;
    current: DOMRect;
    deltaX: number;
    deltaY: number;
    ghost: HTMLElement | null;
    trigger: HTMLElement | null;
    commit?: () => unknown;
}
export interface IResizeCallbackParams {
    event: PointerEvent;
    state: IResizeState;
}
export interface IResizeContainerControllerConfig {
    enabled?: boolean;
    thumbs?: Record<ValuesOf<typeof ResizeDirection>, HTMLElement>;
    mode?: ContainerResizeMode;
    deferredFactory?: ResizeGhostFactory;
    layer?: () => HTMLElement;
    /** Callback invoked at the start of a resize operation. */
    start?: ResizeCallback;
    /** Callback invoked on each pointer move during a resize operation. */
    resize?: ResizeCallback;
    /** Callback invoked when a resize operation completes. */
    end?: ResizeCallback;
    /** Callback invoked when a resize operation is cancelled. */
    cancel?: ResizeCancelCallback;
    /**
     * Optional callback that returns the DOM element which will be resized/resizing depending on the
     * configured mode of the controller.
     *
     * Defaults to the controller host.
     */
    resizeTarget?: () => HTMLElement | undefined;
}
export declare class ResizeContainerController implements ReactiveController {
    private readonly _host;
    private readonly _abortHandle;
    private readonly _options;
    private _id;
    private _hasPointerCapture;
    private _state;
    private _activeRef;
    private _ghost;
    /**
     * Constructs a new instance of the `ResizeContainerController` class.
     *
     * @public
     */
    constructor(host: ReactiveControllerHost & HTMLElement, options?: IResizeContainerControllerConfig);
    /** Whether the controller is enabled and will listen for events. */
    get enabled(): boolean;
    private get _element();
    private get _resizeTarget();
    private get _layer();
    /** Whether the controller is in deferred mode. */
    private get _isDeferred();
    private get _stateParameters();
    hostConnected(): void;
    hostDisconnected(): void;
    /** Stops any resizing operation, cleaning up any additional elements and event listeners. */
    dispose(): void;
    handleEvent(event: PointerEvent & KeyboardEvent): void;
    /** Updates the configuration of the resize controller. */
    set(options?: IResizeContainerControllerConfig): void;
    private _handlePointerDown;
    private _handlePointerMove;
    private _handlePointerEnd;
    private _handleCancel;
    private _shouldSkip;
    private _setActiveRef;
    private _setResizeState;
    private _setResizeCancelListener;
    private _setInitialState;
    private _updateState;
    private _updatePosition;
    private _createGhostElement;
    private _removeGhostElement;
}
export declare function addResizeContainerController(host: ReactiveControllerHost & HTMLElement, options?: IResizeContainerControllerConfig): ResizeContainerController;
//# sourceMappingURL=ResizeContainerController.d.ts.map