import { Graph } from "../../graph";
import { Emitter } from "../../utils/Emitter";
import { TRect } from "../../utils/types/shapes";
import { ECameraScaleLevel } from "./cameraScaleEnums";
export { ECameraScaleLevel } from "./cameraScaleEnums";
export { defaultGetCameraBlockScaleLevel } from "./defaultGetCameraBlockScaleLevel";
export type TCameraState = {
    x: number;
    y: number;
    width: number;
    height: number;
    scale: number;
    scaleMin: number;
    scaleMax: number;
    relativeX: number;
    relativeY: number;
    relativeWidth: number;
    relativeHeight: number;
    /**
     * Insets of visible viewport inside the canvas area (in screen space, pixels)
     * Use these to specify drawers/side panels overlaying the canvas. All values are >= 0.
     */
    viewportInsets: {
        left: number;
        right: number;
        top: number;
        bottom: number;
    };
    /**
     * Auto-panning mode enabled state
     * When enabled, the camera will automatically pan when the mouse is near the viewport edges
     */
    autoPanningEnabled: boolean;
};
export type { TGetCameraBlockScaleLevel } from "./defaultGetCameraBlockScaleLevel";
export declare const getInitCameraState: () => TCameraState;
export type ICamera = Interface<CameraService>;
export declare class CameraService extends Emitter {
    protected graph: Graph;
    protected state: TCameraState;
    constructor(graph: Graph, state?: TCameraState);
    resize(newState: Partial<TCameraState>): void;
    set(newState: Partial<TCameraState>): void;
    private syncCameraSignal;
    private updateRelative;
    getCameraRect(): TRect;
    /**
     * Returns the visible camera rect in screen space that accounts for the viewport insets.
     * @returns {TRect} Visible rectangle inside the canvas after applying insets
     */
    getVisibleCameraRect(): TRect;
    /**
     * Returns camera viewport rectangle in camera-relative space.
     * By default returns full canvas-relative viewport (ignores insets).
     * When options.respectInsets is true, returns viewport of the visible area (with insets applied).
     * @param {Object} [options]
     * @param {boolean} [options.respectInsets]
     * @returns {TRect} Relative viewport rectangle
     */
    getRelativeViewportRect(options?: {
        respectInsets?: boolean;
    }): TRect;
    getCameraScale(): number;
    /**
     * Qualitative zoom tier for blocks. Delegates to `settings.getCameraBlockScaleLevel` (always set; defaults to
     * the exported `defaultGetCameraBlockScaleLevel` strategy).
     * @param cameraScale Optional scale override; defaults to current camera scale
     */
    getCameraBlockScaleLevel(cameraScale?: number): ECameraScaleLevel;
    getCameraState(): TCameraState;
    move(dx?: number, dy?: number): void;
    /**
     * Limits the effect of camera scale on visual details to preserve their visibility.
     * Prevents important details from becoming too large or too small during zoom.
     * Converts absolute value to camera space with optional clamping.
     * @param {number} value Absolute value in screen space
     * @param {number} [max] Maximum allowed value
     * @returns {number} Scale-compensated value in camera space
     */
    limitScaleEffect(value: number, max?: number): number;
    /**
     * Converts a value from absolute (screen space) to relative (camera space).
     * @param {number} n Absolute value
     * @param {number} [scale=this.state.scale] Scale to use for conversion
     * @returns {number} Relative value
     */
    getRelative(n: number, scale?: number): number;
    getRelativeXY(x: number, y: number): number[];
    /**
     * Converts relative coordinate to absolute (screen space).
     * Inverse of getRelative.
     * @param {number} n Relative coordinate
     * @param {number} [scale=this.state.scale] Scale to use for conversion
     * @returns {number} Absolute coordinate in screen space
     */
    getAbsolute(n: number, scale?: number): number;
    /**
     * Converts relative coordinates to absolute (screen space).
     * Inverse of getRelativeXY.
     * @param {number} x Relative x
     * @param {number} y Relative y
     * @returns {number[]} Absolute [x, y] in screen space
     */
    getAbsoluteXY(x: number, y: number): number[];
    /**
     * Zoom to a screen point.
     * @param {number} x Screen x where zoom anchors
     * @param {number} y Screen y where zoom anchors
     * @param {number} scale Target scale value
     * @returns {void}
     */
    zoom(x: number, y: number, scale: number): void;
    getScaleRelativeDimensionsBySide(size: number, axis: "width" | "height", options?: {
        respectInsets?: boolean;
    }): number;
    getScaleRelativeDimensions(width: number, height: number, options?: {
        respectInsets?: boolean;
    }): number;
    getXYRelativeCenterDimensions(dimensions: TRect, scale: number, options?: {
        respectInsets?: boolean;
    }): {
        x: number;
        y: number;
    };
    isRectVisible(x: number, y: number, w: number, h: number): boolean;
    isLineVisible(x1: number, y1: number, x2: number, y2: number): boolean;
    applyToPoint(x: number, y: number): [number, number];
    applyToRect(...arg: number[]): number[];
    /**
     * Update viewport insets (screen-space paddings inside canvas) and optionally keep the
     * world point under the visible center unchanged.
     * @param {Object} insets Partial insets to update
     * @param {number} [insets.left]
     * @param {number} [insets.right]
     * @param {number} [insets.top]
     * @param {number} [insets.bottom]
     * @param {string} [maintain=center] Preserve visual anchor; allowed values: center or none. "center" keeps the
     * same world point under visible center
     * @returns {void}
     */
    setViewportInsets(insets: Partial<TCameraState["viewportInsets"]>, params?: {
        maintain?: "center";
    }): void;
    /**
     * Returns current viewport insets.
     * @returns {{left: number, right: number, top: number, bottom: number}} Current insets of visible viewport
     */
    getViewportInsets(): TCameraState["viewportInsets"];
    /**
     * Enable auto-panning mode.
     * When enabled, the camera will automatically pan when the mouse is near the viewport edges.
     * @returns {void}
     */
    enableAutoPanning(): void;
    /**
     * Disable auto-panning mode.
     * @returns {void}
     */
    disableAutoPanning(): void;
    /**
     * Check if auto-panning mode is enabled.
     * @returns {boolean} True if auto-panning is enabled
     */
    isAutoPanningEnabled(): boolean;
}