import * as _noya_app_noya_geometry from '@noya-app/noya-geometry';
import { Point, Rect, AffineTransform, Region, Size, CompassDirection, Insets, CreateResizeTransformOptions } from '@noya-app/noya-geometry';
import * as React$1 from 'react';
import React__default, { CSSProperties, ComponentPropsWithoutRef, ReactNode, ComponentProps, Dispatch, SetStateAction } from 'react';
import { KeyMap } from '@noya-app/noya-keymap';
import * as _noya_app_noya_infinite_canvas from '@noya-app/noya-infinite-canvas';
import { PointerData as PointerData$1, BaseContextProperties as BaseContextProperties$1, NoneMode as NoneMode$1, ScreenPointProperties as ScreenPointProperties$1, ElementProperties as ElementProperties$1 } from '@noya-app/noya-infinite-canvas';
import { VRange, VOffsetRange, VMeasuredCharacter } from '@noya-app/text-editing';

type IdentifiablePoint = Point & {
    id: string;
};
declare function convertPoint(origin: Point, zoom: number, point: Point, targetCoordinateSystem: "screen" | "canvas"): Point;
declare function convertOffsetPoint(event: EventWithPointAndTarget): Point;
declare const DEFAULT_POINT_HANDLE_SIZE = 8;
/**
 * Transform points from the coordinate space of the rect to the coordinate space of the canvas.
 */
declare function getAbsolutizeTransform(rect: Rect): AffineTransform;
declare function getNormalizeTransform(rect: Rect): AffineTransform;

type BaseContextProperties<M extends BaseMode, D extends object> = {
    getMode: () => M;
    setMode: (mode: React__default.SetStateAction<M>) => void;
    getData: () => D;
    setData: (data: React__default.SetStateAction<D>) => void;
};
type HandleKeyboardEventProperties = {
    handleKeyboardEvent: (keyMap: KeyMap) => (event: React__default.KeyboardEvent) => void;
    setShouldHandleKeyboardEvents: (shouldHandleKeyboardEvents: boolean) => void;
    setReadOnly: (readOnly: boolean) => void;
};
type CanvasRefProperties = {
    canvasRef: React__default.RefObject<HTMLDivElement | null>;
};
type EventWithPointAndTarget = Pick<MouseEvent, "target" | "clientX" | "clientY">;
type ScreenPointProperties = {
    /**
     * Get the clicked point in the screen coordinate system
     */
    getScreenPoint: (input: EventWithPointAndTarget) => Point;
    /**
     * Get the clicked point in the canvas coordinate system
     */
    getCanvasPoint: (input: EventWithPointAndTarget) => Point;
    /**
     * Convert a point between the screen and canvas coordinate systems
     */
    convertPoint: (point: Point, targetCoordinateSystem: "screen" | "canvas") => Point;
};
type PointerCaptureProperties = {
    setPointerCapture: (pointerId: number) => void;
    releasePointerCapture: (pointerId: number) => void;
};
type GetElementsOptions<CanvasElement> = {
    at?: Rect | Point;
    predicate?: (element: CanvasElement) => boolean;
};
type ElementProperties<CanvasElement> = {
    getElementId: (element: CanvasElement) => string;
    filterElements: (options: GetElementsOptions<CanvasElement>) => CanvasElement[];
};
type GetPointsOptions = {
    at?: Rect;
    predicate?: (point: IdentifiablePoint) => boolean;
};
type PointProperties = {
    filterPoints: (options: GetPointsOptions) => IdentifiablePoint[];
    highlightedPointId?: string;
};
type SelectableProperties<CanvasElement> = {
    isSelectable?: (element: CanvasElement) => boolean;
};
type MovableProperties<CanvasElement> = {
    isMovable?: (element: CanvasElement) => boolean;
};
type ScalableProperties<CanvasElement> = {
    isScalable?: (element: CanvasElement) => boolean;
};
type HighlightableProperties<CanvasElement> = {
    isHighlightable?: (element: CanvasElement) => boolean;
};
type PointHighlightableProperties = {
    isPointHighlightable?: (point: IdentifiablePoint) => boolean;
};
type TextEditableProperties<CanvasElement> = {
    isTextEditable?: (element: CanvasElement) => boolean;
};
type FocusProperties = {
    focus: () => void;
};
type DOMContextProperties = PointerCaptureProperties & ScreenPointProperties & HandleKeyboardEventProperties & CanvasRefProperties;

type BaseMode = {
    type: PropertyKey;
};
type BaseEventHandlerMap = Record<PropertyKey, (...args: any[]) => void>;
type Plugin<Mode extends BaseMode, Data extends object, ContextProperties extends object, EventHandlerMap extends BaseEventHandlerMap> = {
    name: string;
    data: Data;
    handlers?: (contextProperties: ContextProperties) => Partial<EventHandlerMap>;
    finalizers?: (contextProperties: ContextProperties) => Partial<EventHandlerMap>;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => CSSProperties["cursor"] | undefined;
    __mode?: Mode;
};
type PluginData<P> = P extends Plugin<any, infer D, any, any> ? D : never;
type PluginMode<P> = P extends Plugin<infer M, any, any, any> ? M : never;
type PluginContextProperties<P> = P extends Plugin<any, any, infer H, any> ? H : never;
type PluginEventHandlerMap<P> = P extends Plugin<any, any, any, infer E> ? E : never;
type PluginSystemMode<P> = P extends PluginSystem<infer M, any, any, any> ? M : never;
type PluginSystemData<P> = P extends PluginSystem<any, infer D, any, any> ? D : never;
type PluginSystemContextProperties<P> = P extends PluginSystem<any, any, infer H, any> ? H : never;
type PluginSystemEventHandlerMap<P> = P extends PluginSystem<any, any, any, infer E> ? E : never;
type AnyPlugin = Plugin<BaseMode, object, any, BaseEventHandlerMap>;
type AnyPluginSystem = PluginSystem<BaseMode, object, any, BaseEventHandlerMap>;
/**
 * Ensure that any switch statement over a mode type handles the default case.
 * This helps make sure the system is resilient to new modes being added.
 */
declare const UnhandledSymbol: unique symbol;
type NoneMode = {
    type: "none";
} | {
    type: typeof UnhandledSymbol;
};
type HandlerMap<ContextProperties extends object, EventHandlerMap extends BaseEventHandlerMap> = {
    name: string;
    handlers: (contextProperties: ContextProperties) => Partial<EventHandlerMap>;
    finalizers: (contextProperties: ContextProperties) => Partial<EventHandlerMap>;
};
type PluginSystemOptions<ContextProperties extends object> = {
    debugFilter?: boolean | string | RegExp;
    debugInfoFromContext?: (context: ContextProperties) => string;
};
type GetCursorUnknown = ({ data, mode, }: {
    data: unknown;
    mode: unknown;
}) => CSSProperties["cursor"] | undefined;
declare class PluginSystem<Mode extends BaseMode, Data extends object, ContextProperties extends object, EventHandlerMap extends BaseEventHandlerMap> {
    static create(): PluginSystem<NoneMode, {}, {}, {}>;
    mode: Mode;
    data: Data;
    handlerMaps: HandlerMap<ContextProperties, EventHandlerMap>[];
    options: PluginSystemOptions<ContextProperties>;
    getCursor: GetCursorUnknown;
    constructor({ mode, data, handlerMaps, options, getCursor, }: {
        mode: Mode;
        data: Data;
        handlerMaps: HandlerMap<ContextProperties, EventHandlerMap>[];
        options: PluginSystemOptions<ContextProperties>;
        getCursor: GetCursorUnknown;
    });
    get contextProperties(): ContextProperties;
    debugLog(context: ContextProperties, ...args: any[]): void;
    addMode<M extends BaseMode>(): PluginSystem<Mode | M, Data, ContextProperties, EventHandlerMap>;
    addData<D extends object>(data: D): PluginSystem<Mode, Data & D, ContextProperties, EventHandlerMap>;
    addContextProperties<H extends object>(): PluginSystem<Mode, Data, ContextProperties & H, EventHandlerMap>;
    addEventHandlers<E extends BaseEventHandlerMap>(handlerMap?: HandlerMap<ContextProperties, E>): PluginSystem<Mode, Data, ContextProperties, EventHandlerMap & E>;
    addPlugin<M extends BaseMode, D extends object, H extends object, E extends BaseEventHandlerMap>(plugin: Plugin<M, D, H, E>): PluginSystem<Mode | M, Data & D, ContextProperties & H, EventHandlerMap & E>;
    addPlugins<Plugins extends AnyPlugin[]>(...plugins: Plugins): PluginsToSystem<Plugins>;
    addOptions(options: PluginSystemOptions<ContextProperties>): PluginSystem<Mode, Data, ContextProperties, EventHandlerMap>;
    addGetCursor(getCursor: GetCursorUnknown): PluginSystem<Mode, Data, ContextProperties, EventHandlerMap>;
    callEventHandler<K extends keyof EventHandlerMap>(context: ContextProperties, key: K, ...args: Parameters<EventHandlerMap[K]>): void;
    getAllEventNames(context: ContextProperties): (keyof EventHandlerMap)[];
    getHandlers(context: ContextProperties): Partial<EventHandlerMap>;
    clone(): PluginSystem<Mode, Data, ContextProperties, EventHandlerMap>;
}
type ModeHandlerMap<M extends BaseMode> = {
    [K in M["type"]]?: (mode: Extract<M, {
        type: K;
    }>) => void;
};
declare function modeSwitch<M extends BaseMode, K extends M["type"]>(mode: Extract<M, {
    type: K;
}>, handlers: ModeHandlerMap<M>): void | undefined;
type PluginsToSystem<Plugins extends AnyPlugin[]> = PluginsToSystemRecurse<never, {}, {}, {}, Plugins>;
type PluginsToSystemRecurse<Mode extends BaseMode, Data extends object, UniqueContextProperties extends object, EventHandlerMap extends BaseEventHandlerMap, Plugins extends readonly AnyPlugin[]> = Plugins extends readonly [
    Plugin<infer M, infer D, infer H, infer E>,
    ...infer Tail extends AnyPlugin[]
] ? PluginsToSystemRecurse<Mode | M, Data & D, UniqueContextProperties & Omit<H, keyof BaseContextProperties<any, any>>, EventHandlerMap & E, Tail> : PluginSystem<Mode, Data, BaseContextProperties<Mode, Data> & UniqueContextProperties, EventHandlerMap>;

type PointerMode = NoneMode;
type PointerData = {
    pointer?: Point;
    pointerDown?: Region;
    clickCount?: number;
    lastClickTime?: number;
    lastClickScreenPoint?: Point;
    lastRightClickCanvasPoint?: Point;
    rawPointer?: Point;
};
interface UniquePointerContextProperties {
    adjustPoint?: (event: React.PointerEvent, point: Point) => Point;
    completedPointer?: (event: React.PointerEvent, region: Region, clickCount: number) => void;
}
interface PointerContextProperties extends BaseContextProperties<PointerMode, PointerData>, ScreenPointProperties, PointerCaptureProperties, UniquePointerContextProperties {
}
type PointerPluginOptions = {
    clickTimeThreshold?: number;
};
declare function pointerPlugin(options?: PointerPluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & PointerData;
    name: string;
    handlers?: ((contextProperties: PointerContextProperties & BaseContextProperties<NoneMode, PointerData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: PointerContextProperties & BaseContextProperties<NoneMode, PointerData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: NoneMode | undefined;
};

type BaseCanvasData = {
    size: Size;
    zoom: number;
    origin: Point;
};
type AnyCanvasPlugin = Plugin<BaseMode, BaseCanvasData & PointerData, any, ReactEventHandlerMap>;
type AnyCanvasPluginSystem = PluginSystem<BaseMode, BaseCanvasData & PointerData, any, ReactEventHandlerMap>;
declare const initialBaseCanvasData: BaseCanvasData;
declare const initialPointerData: PointerData;
type ReactEventHandlerMap = {
    onWheel: (event: React__default.WheelEvent) => void;
    onPointerEnter: (event: React__default.PointerEvent) => void;
    onPointerLeave: (event: React__default.PointerEvent) => void;
    onPointerDown: (event: React__default.PointerEvent) => void;
    onPointerMove: (event: React__default.PointerEvent) => void;
    onPointerUp: (event: React__default.PointerEvent) => void;
    onPointerCancel: (event: React__default.PointerEvent) => void;
    onGotPointerCapture: (event: React__default.PointerEvent) => void;
    onLostPointerCapture: (event: React__default.PointerEvent) => void;
    onKeyDown: (event: React__default.KeyboardEvent) => void;
    onKeyUp: (event: React__default.KeyboardEvent) => void;
    onBeforeInput: (event: InputEvent) => void;
};
declare function createCanvasPlugin<Mode extends BaseMode, Data extends object, ContextProperties extends object>(plugin: Omit<Plugin<Mode, Data, ContextProperties & BaseContextProperties<Mode, Data>, ReactEventHandlerMap>, "getCursor"> & {
    getCursor?: ({ data, mode, }: {
        data: Data;
        mode: Mode;
    }) => string | undefined;
}): {
    data: {
        size: Size;
        zoom: number;
        origin: Point;
    } & Data;
    name: string;
    handlers?: ((contextProperties: ContextProperties & BaseContextProperties<Mode, Data>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: ContextProperties & BaseContextProperties<Mode, Data>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React__default.CSSProperties["cursor"] | undefined;
    __mode?: Mode | undefined;
};
declare function getCanvasTransform(data: {
    origin: {
        x: number;
        y: number;
    };
    zoom: number;
}): AffineTransform;

type ScalingOriginMode = "extent" | "center";
type ScalingOptions = {
    preserveAspectRatio: boolean;
    scalingOriginMode: ScalingOriginMode;
    ignoreSnapping: boolean;
};
declare function getScalingOptionsForEvent({ shiftKey, altKey, ctrlKey, }: {
    shiftKey: boolean;
    altKey: boolean;
    ctrlKey: boolean;
}): ScalingOptions;
declare function getRectExtentPoint(rect: Rect, direction: CompassDirection): {
    x: number;
    y: number;
};
/**
 * Resize a rect in a compass direction
 */
declare function getScaleTransform(rect: Rect, delta: Point | Region, direction: CompassDirection, { scalingOriginMode, preserveAspectRatio }: ScalingOptions): AffineTransform;
declare function getScaleSnapDelta({ movingRects, stationaryRects, delta, direction, gridSize, }: {
    movingRects: Rect[];
    stationaryRects: Rect[];
    delta: Point;
    direction: CompassDirection;
    gridSize: Size;
}): Point;

type ScaleMode<StateSnapshot> = NoneMode | {
    type: "scaling";
    delta: Point;
    snapshot: StateSnapshot;
    direction: CompassDirection;
    options: ScalingOptions;
};
type ScaleData = {
    zoom: number;
    selectedElementIds: string[];
    dragHandleSize: number;
    hoveredDragHandleDirection?: CompassDirection;
} & Pick<PointerData, "pointerDown" | "pointer">;
type ScaleElementParameters<StateSnapshot> = {
    elementIds: string[];
    delta: Point;
    snapshot: StateSnapshot;
    direction: CompassDirection;
    options: ScalingOptions;
};
interface ScaleContextProperties<CanvasElement, StateSnapshot> extends BaseContextProperties<ScaleMode<StateSnapshot>, ScaleData>, ElementProperties<CanvasElement>, ScalableProperties<CanvasElement> {
    getStateSnapshot: () => StateSnapshot;
    adjustScaleDelta?: (event: React.PointerEvent, parameters: ScaleElementParameters<StateSnapshot>) => Point;
    scaleElements: (parameters: ScaleElementParameters<StateSnapshot>) => void;
    /**
     * Returns the union of the selected elements' rects, in canvas coordinates (no transform).
     */
    getSelectionRect: () => Rect | undefined;
    canScale?: () => boolean;
}
type ScalePluginOptions = {
    movementThreshold?: number;
    dragHandleSize?: number;
};
declare const DEFAULT_DRAG_HANDLE_SIZE = 8;
declare function scalePlugin<CanvasElement, StateSnapshot>(options?: ScalePluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & {
        zoom: number;
        selectedElementIds: string[];
        dragHandleSize: number;
        hoveredDragHandleDirection?: CompassDirection;
    } & Pick<PointerData, "pointer" | "pointerDown">;
    name: string;
    handlers?: ((contextProperties: ScaleContextProperties<CanvasElement, StateSnapshot> & BaseContextProperties<ScaleMode<StateSnapshot>, ScaleData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: ScaleContextProperties<CanvasElement, StateSnapshot> & BaseContextProperties<ScaleMode<StateSnapshot>, ScaleData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: ScaleMode<StateSnapshot> | undefined;
};

declare function DragHandles({ selectionRect, data, }: {
    selectionRect?: Rect;
    data?: Pick<BaseCanvasData, "zoom" | "origin"> & Pick<ScaleData, "dragHandleSize" | "hoveredDragHandleDirection">;
}): React__default.JSX.Element;

declare const DEFAULT_GRADIENT_HANDLE_SIZE = 12;
declare const GRADIENT_EDITOR_SURFACE_ATTRIBUTE = "data-gradient-editor-surface";
type GradientStopHandle = {
    id: string;
    index: number;
    type: "start" | "end" | "stop";
    position: number;
    point: Point;
    color?: string;
};
type GradientEditorGradient = {
    rect: Rect;
    stops: GradientStopHandle[];
};
type GradientEditorMode<StateSnapshot> = NoneMode | {
    type: "draggingGradientStop";
    stopId: string;
    snapshot: StateSnapshot;
};
type GradientEditorData = {
    handleSize: number;
    hoveredStopId?: string;
    activeStopId?: string;
    zoom: number;
} & Pick<PointerData, "pointer" | "pointerDown">;
interface GradientEditorContextProperties<StateSnapshot> extends BaseContextProperties<GradientEditorMode<StateSnapshot>, GradientEditorData>, ScreenPointProperties {
    canEditGradient: () => boolean;
    getGradient: () => GradientEditorGradient | undefined;
    getStateSnapshot: () => StateSnapshot;
    moveStop: (parameters: {
        id: string;
        point: Point;
        position: number;
        snapshot: StateSnapshot;
    }) => void;
}
type GradientEditorPluginOptions = {
    handleSize?: number;
    movementThreshold?: number;
};
declare function gradientEditorPlugin<StateSnapshot>(options?: GradientEditorPluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & {
        handleSize: number;
        hoveredStopId?: string;
        activeStopId?: string;
        zoom: number;
    } & Pick<PointerData, "pointer" | "pointerDown">;
    name: string;
    handlers?: ((contextProperties: GradientEditorContextProperties<StateSnapshot> & BaseContextProperties<GradientEditorMode<StateSnapshot>, GradientEditorData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: GradientEditorContextProperties<StateSnapshot> & BaseContextProperties<GradientEditorMode<StateSnapshot>, GradientEditorData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: GradientEditorMode<StateSnapshot> | undefined;
};
declare function useGradientEditor(): {
    data: {
        handleSize: number;
        hoveredStopId?: string;
        activeStopId?: string;
        zoom: number;
    } & Pick<PointerData, "pointer" | "pointerDown"> & BaseCanvasData;
    mode: GradientEditorMode<unknown>;
    gradient: GradientEditorGradient | undefined;
};

declare function GradientHandles({ gradient, data, mode, }: {
    gradient?: GradientEditorGradient;
    data?: GradientEditorData & Pick<BaseCanvasData, "origin" | "zoom">;
    mode?: GradientEditorMode<unknown>;
}): React__default.JSX.Element | null;

type MeasuredChildren = ReactNode | (({ size }: {
    size: Size;
}) => ReactNode);
interface InfiniteCanvasProps extends Omit<ComponentPropsWithoutRef<"div">, "onBeforeInput" | "children"> {
    onBeforeInput?: (e: InputEvent) => void;
    onChangeSize?: (size: Size, insets: Insets) => void;
    size?: Size;
    insets?: Insets;
    autoFocus?: boolean;
    children: MeasuredChildren;
    readOnly?: boolean;
    shouldHandleKeyboardEvents?: boolean;
    /**
     * When true, indicates the user is actively editing text.
     * On touch devices, contentEditable is only enabled when this is true,
     * to prevent the keyboard from appearing during touch/drag interactions.
     */
    isEditingText?: boolean;
}
declare const InfiniteCanvas: React__default.NamedExoticComponent<InfiniteCanvasProps & React__default.RefAttributes<HTMLDivElement>>;

declare function Marquee({ data, mode, }: {
    data?: Pick<BaseCanvasData, "zoom" | "origin">;
    mode?: BaseMode;
}): React__default.JSX.Element | null;

type PointMode<StateSnapshot> = NoneMode | {
    type: "movingPoint";
    region: Region;
    snapshot: StateSnapshot;
    id: string;
};
type PointData = {
    highlightedPointId?: string;
    pointHandleSize: number;
    zoom: number;
} & Pick<PointerData, "pointerDown" | "pointer">;
type PointPluginOptions = {
    pointHandleSize?: number;
    movementThreshold?: number;
    pointHandleHitSize?: number;
};
interface PointContextProperties<StateSnapshot> extends BaseContextProperties<PointMode<StateSnapshot>, PointData>, ScreenPointProperties, PointProperties, PointHighlightableProperties {
    getStateSnapshot: () => StateSnapshot;
    getPoints: () => {
        points: IdentifiablePoint[];
        rect: Rect;
    } | undefined;
    movePoint: (params: {
        id: string;
        region: Region;
        snapshot: StateSnapshot;
    }) => void;
}
declare function pointPlugin<StateSnapshot>(options?: PointPluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    } & {
        highlightedPointId?: string;
        pointHandleSize: number;
        zoom: number;
    } & Pick<PointerData, "pointer" | "pointerDown">;
    name: string;
    handlers?: ((contextProperties: PointContextProperties<StateSnapshot> & BaseContextProperties<PointMode<StateSnapshot>, PointData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: PointContextProperties<StateSnapshot> & BaseContextProperties<PointMode<StateSnapshot>, PointData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: PointMode<StateSnapshot> | undefined;
};

declare function PointHandles({ points, data, }: {
    points: {
        point: IdentifiablePoint;
        pathRect: Rect;
    }[];
    data?: Pick<BaseCanvasData, "zoom" | "origin"> & Pick<ScaleData, "dragHandleSize"> & PointData;
}): React__default.JSX.Element;

declare function SelectionRect({ selectionRect, borderRadius, data, }: {
    selectionRect?: Rect;
    borderRadius?: number;
    data?: Pick<BaseCanvasData, "zoom" | "origin">;
}): React__default.JSX.Element | null;

type SnapLine = {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
};
declare function getValuesOnAxis(rects: Rect | Rect[], axis: "x" | "y"): number[];
declare function getElementSnapDelta({ movingValues, stationaryValues, proximity, }: {
    movingValues: number[];
    stationaryValues: number[];
    proximity?: number;
}): number | null;
declare function getSnapLines({ movingRect, stationaryRects, axis, proximity, }: {
    movingRect: Rect;
    stationaryRects: Rect[];
    axis: "x" | "y";
    proximity?: number;
}): SnapLine[];
declare function getGridSnapDelta({ value, gridSize, }: {
    value: number;
    gridSize: number;
}): number;
declare function getBestSnapDelta(snaps: (number | null)[]): number;

type SnapLinesProps = {
    lines: SnapLine[];
    color?: string;
    data?: Pick<BaseCanvasData, "zoom">;
};
declare const SnapLines: React__default.FC<SnapLinesProps>;

declare function useMultipleClickCount(): {
    getClickCount: () => number;
    setLatestClick: (point: Point) => number;
};

type BaseDOMElementRef = {
    getBoundingClientRect: () => DOMRect;
};
type DOMEventMode<DOMElementRef> = NoneMode$1 | {
    type: "domPointerDown";
    element: DomElementAtPoint<DOMElementRef>;
};
type DOMEventData<DOMElementRef> = {
    domElementRefs: Record<string, React.RefObject<DOMElementRef | null>>;
    hoveredDomElementId: string | undefined;
} & Pick<PointerData$1, "pointerDown">;
interface DOMEventContextProperties<DOMElementRef> extends BaseContextProperties$1<DOMEventMode<DOMElementRef>, DOMEventData<DOMElementRef>> {
    onClickDomElement?: (event: React.MouseEvent, options: {
        id: string;
        ref?: React.RefObject<DOMElementRef | null>;
    }) => void;
}
declare function domEventPlugin<DOMElementRef extends BaseDOMElementRef>(): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    } & {
        domElementRefs: Record<string, React$1.RefObject<DOMElementRef | null>>;
        hoveredDomElementId: string | undefined;
    } & Pick<PointerData$1, "pointerDown">;
    name: string;
    handlers?: ((contextProperties: DOMEventContextProperties<DOMElementRef> & BaseContextProperties$1<DOMEventMode<DOMElementRef>, DOMEventData<DOMElementRef>>) => Partial<_noya_app_noya_infinite_canvas.ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: DOMEventContextProperties<DOMElementRef> & BaseContextProperties$1<DOMEventMode<DOMElementRef>, DOMEventData<DOMElementRef>>) => Partial<_noya_app_noya_infinite_canvas.ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: DOMEventMode<DOMElementRef> | undefined;
};
type DomElementAtPoint<DOMElementRef> = {
    id: string;
    ref: React.RefObject<DOMElementRef | null>;
};

type SelectionPoint = VRange["anchor"];
type SelectionRange = VRange;
declare const TEXT_SELECTION_PATH: number[];
declare function selectionToOffsetRange(range: SelectionRange | null, textLength: number): VOffsetRange | null;
declare function offsetRangeToSelection(range: VOffsetRange): SelectionRange;

type EditingTextMode$1 = {
    editingElementId: string;
    range: SelectionRange | null;
    type: "editingText";
};
type DomTextMode = NoneMode | EditingTextMode$1;
type DomTextData = {
    zoom: number;
} & PointerData;
interface DomTextContextProperties<CanvasElement> extends BaseContextProperties<DomTextMode, DomTextData>, HandleKeyboardEventProperties, ScreenPointProperties, ElementProperties<CanvasElement>, TextEditableProperties<CanvasElement> {
    mouseDown: ({ clientPoint, elementId, }: {
        clientPoint: Point;
        elementId: string;
    }) => void;
    mouseMove: ({ clientPoint, elementId, }: {
        clientPoint: Point;
        elementId: string;
    }) => void;
    mouseUp: ({ clientPoint, elementId, }: {
        clientPoint: Point;
        elementId: string;
    }) => void;
    onBlur: (elementId: string) => void;
}
type DomTextPluginOptions = {};
declare function domTextPlugin<CanvasElement>(_options?: DomTextPluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & {
        zoom: number;
    } & PointerData;
    name: string;
    handlers?: ((contextProperties: DomTextContextProperties<CanvasElement> & BaseContextProperties<DomTextMode, DomTextData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: DomTextContextProperties<CanvasElement> & BaseContextProperties<DomTextMode, DomTextData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: DomTextMode | undefined;
};

declare function doubleClickPlugin<CanvasElement>(): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    } & PointerData$1;
    name: string;
    handlers?: ((contextProperties: BaseContextProperties$1<NoneMode$1, PointerData$1> & ScreenPointProperties$1 & ElementProperties$1<CanvasElement> & {
        handleDoubleClick: (options: {
            elementId: string;
        }) => void;
    }) => Partial<_noya_app_noya_infinite_canvas.ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: BaseContextProperties$1<NoneMode$1, PointerData$1> & ScreenPointProperties$1 & ElementProperties$1<CanvasElement> & {
        handleDoubleClick: (options: {
            elementId: string;
        }) => void;
    }) => Partial<_noya_app_noya_infinite_canvas.ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: NoneMode$1 | undefined;
};

type DrawingMode = NoneMode | {
    type: "drawing";
    region: Region;
};
type DrawingData = {
    zoom: number;
    drawnPoints: IdentifiablePoint[];
} & Pick<PointerData, "pointerDown">;
interface DrawingHandlerContext<CanvasElement> extends BaseContextProperties<DrawingMode, DrawingData>, ElementProperties<CanvasElement>, SelectableProperties<CanvasElement> {
    canDraw?: (event: React.PointerEvent) => boolean;
    adjustDrawingPoint?: (event: React.PointerEvent, point: Point) => Point;
    adjustDrawingRegion?: (event: React.PointerEvent, region: Region) => Region;
    addDrawnPoint?: (event: React.PointerEvent, point: IdentifiablePoint) => void;
    addDrawnElement?: (event: React.PointerEvent, region: Region) => BaseMode | undefined;
}
type DrawingPluginOptions = {
    movementThreshold?: number;
};
declare function drawingPlugin<CanvasElement>(options?: DrawingPluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & {
        zoom: number;
        drawnPoints: IdentifiablePoint[];
    } & Pick<PointerData, "pointerDown">;
    name: string;
    handlers?: ((contextProperties: DrawingHandlerContext<CanvasElement> & BaseContextProperties<DrawingMode, DrawingData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: DrawingHandlerContext<CanvasElement> & BaseContextProperties<DrawingMode, DrawingData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: DrawingMode | undefined;
};

type EditingTextMode = {
    editingElementId: string;
    range: VRange | null;
    type: "editingText";
};
type EditTextMode = NoneMode | EditingTextMode;
type EditTextData = {
    zoom: number;
    selectedElementIds?: string[];
    textDragAnchor?: number | null;
    isDraggingText?: boolean;
    textSelectionUnit?: "character" | "word" | "paragraph";
    textInitialSelection?: {
        anchor: number;
        focus: number;
    } | null;
} & PointerData;
type TextEditElement = {
    id: string;
    rect: Rect;
    text: string;
};
type TextMeasurement = {
    measuredCharacters: VMeasuredCharacter[];
};
interface EditTextContextProperties<CanvasElement> extends BaseContextProperties<EditTextMode, EditTextData>, HandleKeyboardEventProperties, ScreenPointProperties, ElementProperties<CanvasElement>, TextEditableProperties<CanvasElement> {
    getTextElement: (elementId: string) => TextEditElement | undefined;
    updateText: (elementId: string, nextText: string) => void;
    measureText?: (element: TextEditElement) => TextMeasurement | undefined;
    hitTestText?: (element: TextEditElement, parameters: {
        canvasPoint: Point;
        localPoint: Point;
    }) => number | undefined;
    getSelectedTextElementId?: () => string | undefined;
    onTextPointerDown?: (event: React__default.PointerEvent, elementId: string) => void;
    onTextPointerMove?: (event: React__default.PointerEvent, elementId: string) => void;
    onTextPointerUp?: (event: React__default.PointerEvent, elementId: string) => void;
    onBlur?: (elementId: string) => void;
}
type EditTextPluginOptions = {
    triggerEvent?: "click" | "doubleClick";
};
declare function editTextPlugin<CanvasElement>(options?: EditTextPluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & {
        zoom: number;
        selectedElementIds?: string[];
        textDragAnchor?: number | null;
        isDraggingText?: boolean;
        textSelectionUnit?: "character" | "word" | "paragraph";
        textInitialSelection?: {
            anchor: number;
            focus: number;
        } | null;
    } & PointerData;
    name: string;
    handlers?: ((contextProperties: EditTextContextProperties<CanvasElement> & BaseContextProperties<EditTextMode, EditTextData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: EditTextContextProperties<CanvasElement> & BaseContextProperties<EditTextMode, EditTextData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React__default.CSSProperties["cursor"] | undefined;
    __mode?: EditTextMode | undefined;
};

type EraserMode = NoneMode | {
    type: "erasing";
};
type EraserData = {
    markedForErasureElementIds: string[];
} & PointerData;
interface EraserContextProperties<CanvasElement> extends BaseContextProperties<EraserMode, EraserData>, ElementProperties<CanvasElement> {
    canErase?: (event: React.PointerEvent) => boolean;
    adjustErasePoint?: (event: React.PointerEvent, point: Point) => Point;
    onEraseElements?: (elementIds: string[]) => void;
}
declare function eraserPlugin<CanvasElement>(): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & {
        markedForErasureElementIds: string[];
    } & PointerData;
    name: string;
    handlers?: ((contextProperties: EraserContextProperties<CanvasElement> & BaseContextProperties<EraserMode, EraserData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: EraserContextProperties<CanvasElement> & BaseContextProperties<EraserMode, EraserData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: EraserMode | undefined;
};

type FocusMode = NoneMode;
type FocusData = {};
interface FocusContextContext extends BaseContextProperties<FocusMode, FocusData>, CanvasRefProperties {
}
declare function focusPlugin(): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    };
    name: string;
    handlers?: ((contextProperties: FocusContextContext & BaseContextProperties<NoneMode, {}>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: FocusContextContext & BaseContextProperties<NoneMode, {}>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: NoneMode | undefined;
};

type GradientEditorLinearGradient = {
    from: Point;
    to: Point;
    stops: {
        color: string;
        offset: number;
    }[];
};
type GradientEditorDetails = {
    gradient: GradientEditorGradient;
    stopMap: Map<string, number>;
};
declare function createGradientEditorDetails({ linearGradient, artRect, transform, }: {
    linearGradient: GradientEditorLinearGradient;
    artRect: Rect;
    transform: AffineTransform;
}): GradientEditorDetails;

type HighlightMode = NoneMode;
type HighlightData = {
    highlightedElementId: string | undefined;
};
interface HighlightContextProperties<CanvasElement> extends BaseContextProperties<HighlightMode, HighlightData>, ScreenPointProperties, ElementProperties<CanvasElement>, HighlightableProperties<CanvasElement> {
}
declare function highlightPlugin<CanvasElement>(): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    } & HighlightData;
    name: string;
    handlers?: ((contextProperties: HighlightContextProperties<CanvasElement> & BaseContextProperties<NoneMode, HighlightData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: HighlightContextProperties<CanvasElement> & BaseContextProperties<NoneMode, HighlightData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: NoneMode | undefined;
};

type LineHandleCoordinates = {
    rect: Rect;
    start: IdentifiablePoint;
    end: IdentifiablePoint;
};
type LineMode<StateSnapshot> = NoneMode | {
    type: "movingLinePoint";
    region: Region;
    snapshot: StateSnapshot;
    id: string;
};
type LineData = {
    highlightedPointId?: string;
    pointHandleSize: number;
    zoom: number;
} & Pick<PointerData, "pointerDown" | "pointer">;
type LinePluginOptions = {
    pointHandleSize?: number;
    movementThreshold?: number;
};
interface LineContextProperties<StateSnapshot> extends BaseContextProperties<LineMode<StateSnapshot>, LineData>, ScreenPointProperties {
    getLine: () => LineHandleCoordinates | undefined;
    getStateSnapshot: () => StateSnapshot;
    moveLinePoint: (params: {
        id: string;
        region: Region;
        snapshot: StateSnapshot;
    }) => void;
    canEditLine?: () => boolean;
}
declare function linePlugin<StateSnapshot>(options?: LinePluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    } & {
        highlightedPointId?: string;
        pointHandleSize: number;
        zoom: number;
    } & Pick<PointerData, "pointer" | "pointerDown">;
    name: string;
    handlers?: ((contextProperties: LineContextProperties<StateSnapshot> & BaseContextProperties<LineMode<StateSnapshot>, LineData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: LineContextProperties<StateSnapshot> & BaseContextProperties<LineMode<StateSnapshot>, LineData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: LineMode<StateSnapshot> | undefined;
};

type MarqueeMode = {
    type: "marquee";
    region: Region;
    selectedElementIdsSnapshot: string[];
};
declare function isMarqueeMode(mode: BaseMode): mode is MarqueeMode;
type MarqueePluginMode = NoneMode | MarqueeMode;
type MarqueeData = {
    selectedElementIds: string[];
    zoom: number;
} & Pick<PointerData, "pointerDown">;
interface MarqueeHandlerContext<CanvasElement> extends BaseContextProperties<MarqueePluginMode, MarqueeData>, ElementProperties<CanvasElement>, SelectableProperties<CanvasElement> {
    adjustMarqueeRegion?: (event: React.PointerEvent, region: Region) => Region;
}
type MarqueePluginOptions = {
    movementThreshold?: number;
};
declare function marqueePlugin<CanvasElement>(options?: MarqueePluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    } & {
        selectedElementIds: string[];
        zoom: number;
    } & Pick<PointerData, "pointerDown">;
    name: string;
    handlers?: ((contextProperties: MarqueeHandlerContext<CanvasElement> & BaseContextProperties<MarqueePluginMode, MarqueeData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: MarqueeHandlerContext<CanvasElement> & BaseContextProperties<MarqueePluginMode, MarqueeData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: MarqueePluginMode | undefined;
};

type MovingOptions = {
    constrainToSingleAxis?: boolean;
    ignoreSnapping?: boolean;
};
declare function getMovingOptionsForEvent({ shiftKey, ctrlKey, }: {
    shiftKey: boolean;
    ctrlKey: boolean;
}): MovingOptions;
declare function getMoveTransform(delta: Point | Region, { constrainToSingleAxis }: MovingOptions): AffineTransform;
declare function getMoveSnapDelta({ movingRects, stationaryRects, delta, gridSize, options, }: {
    movingRects: Rect[];
    stationaryRects: Rect[];
    delta: Point;
    gridSize: Size;
    options: MovingOptions;
}): {
    x: number;
    y: number;
};

type MoveMode<StateSnapshot> = NoneMode | {
    type: "moving";
    delta: Point;
    snapshot: StateSnapshot;
};
type MoveData = {
    zoom: number;
    selectedElementIds: string[];
} & Pick<PointerData, "pointerDown">;
type MoveElementParameters<StateSnapshot> = {
    elementIds: string[];
    delta: Point;
    snapshot: StateSnapshot;
    options: MovingOptions;
};
type DuplicateElementsResult<StateSnapshot> = Pick<MoveElementParameters<StateSnapshot>, "elementIds" | "snapshot">;
interface MoveContextProperties<CanvasElement, StateSnapshot> extends BaseContextProperties<MoveMode<StateSnapshot>, MoveData>, ElementProperties<CanvasElement>, MovableProperties<CanvasElement> {
    adjustMoveDelta?: (event: React.PointerEvent, options: MoveElementParameters<StateSnapshot>) => Point;
    finalizeMove?: (options: MoveElementParameters<StateSnapshot>) => void;
    duplicateElements?: (event: React.PointerEvent, options: MoveElementParameters<StateSnapshot>) => DuplicateElementsResult<StateSnapshot> | undefined;
    getStateSnapshot: () => StateSnapshot;
    moveElements: (parameters: MoveElementParameters<StateSnapshot>) => void;
}
type MovePluginOptions = {
    movementThreshold?: number;
};
declare function movePlugin<CanvasElement, StateSnapshot>(options?: MovePluginOptions): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: Point;
    } & {
        zoom: number;
        selectedElementIds: string[];
    } & Pick<PointerData, "pointerDown">;
    name: string;
    handlers?: ((contextProperties: MoveContextProperties<CanvasElement, StateSnapshot> & BaseContextProperties<MoveMode<StateSnapshot>, MoveData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: MoveContextProperties<CanvasElement, StateSnapshot> & BaseContextProperties<MoveMode<StateSnapshot>, MoveData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: MoveMode<StateSnapshot> | undefined;
};

type ReturnTo = "none" | "panMode";
type PanMode = NoneMode | {
    type: "panMode";
} | {
    type: "maybePan";
    origin: Point;
    returnTo: ReturnTo;
} | {
    type: "panning";
    previous: Point;
    next: Point;
    returnTo: ReturnTo;
};
type PanData = {
    size: Size;
    origin: Point;
};
interface PanContextProperties extends BaseContextProperties<PanMode, PanData>, HandleKeyboardEventProperties, ScreenPointProperties {
    isHandActive?: () => boolean;
}
type PanOptions = {
    onWheelShouldPreventDefault?: boolean;
    modiferKeyShouldDisablePan?: boolean;
};
declare function panPlugin(options?: PanOptions): {
    data: {
        size: Size;
        zoom: number;
        origin: Point;
    } & {
        size: {
            width: number;
            height: number;
        };
        origin: {
            x: number;
            y: number;
        };
    };
    name: string;
    handlers?: ((contextProperties: PanContextProperties & BaseContextProperties<PanMode, {
        size: {
            width: number;
            height: number;
        };
        origin: {
            x: number;
            y: number;
        };
    }>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: PanContextProperties & BaseContextProperties<PanMode, {
        size: {
            width: number;
            height: number;
        };
        origin: {
            x: number;
            y: number;
        };
    }>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: PanMode | undefined;
};

type AllBaseContextProperties<Mode extends BaseMode, Data extends BaseCanvasData & PointerData> = BaseContextProperties<Mode, Data> & DOMContextProperties;
type ContextPropertiesWithoutBase<Mode extends BaseMode, Data extends BaseCanvasData & PointerData, ContextProperties extends object> = Omit<ContextProperties, keyof AllBaseContextProperties<Mode, Data>>;
type ContextPropertiesBaseFixType<Mode extends BaseMode, Data extends BaseCanvasData & PointerData, ContextProperties extends object> = ContextPropertiesWithoutBase<Mode, Data, ContextProperties> & AllBaseContextProperties<Mode, Data>;
type PluginSystemToReactCanvas<PS extends AnyCanvasPluginSystem> = ReactCanvas<PluginSystemMode<PS>, PluginSystemData<PS>, PluginSystemContextProperties<PS>, PluginSystemEventHandlerMap<PS>>;
declare class ReactCanvas<Mode extends BaseMode, Data extends BaseCanvasData & PointerData, ContextProperties extends object, EventHandlerMap extends ReactEventHandlerMap> {
    pluginSystem: PluginSystem<Mode, Data, ContextProperties, EventHandlerMap>;
    private constructor();
    static create(): ReactCanvas<NoneMode, BaseCanvasData & PointerData, {}, ReactEventHandlerMap>;
    addPlugin<M extends BaseMode, D extends BaseCanvasData & PointerData, H extends object, E extends ReactEventHandlerMap>(plugin: Plugin<M, D, H, E>): ReactCanvas<Mode | M, Data & D, ContextProperties & H, EventHandlerMap & E>;
    addPlugins<P extends AnyCanvasPlugin[]>(...plugins: P): PluginSystemToReactCanvas<CanvasPluginsToSystem<P>>;
    addOptions(options: PluginSystemOptions<ContextProperties>): ReactCanvas<Mode, Data, ContextProperties, EventHandlerMap>;
    get initialMode(): Mode;
    get initialData(): Data;
    PropertiesRefContext: React__default.Context<ContextPropertiesBaseFixType<Mode, Data, ContextProperties> | undefined>;
    ModeContext: React__default.Context<Mode | undefined>;
    DataContext: React__default.Context<Data | undefined>;
    ModeProvider: React__default.Provider<Mode | undefined>;
    DataProvider: React__default.Provider<Data | undefined>;
    useContextPropertiesRef: () => ContextPropertiesBaseFixType<Mode, Data, ContextProperties>;
    useMode: () => Mode;
    useData: () => Data;
    Canvas: React__default.ForwardRefExoticComponent<Omit<{
        mode?: Mode;
        data?: Data;
        contextProperties: (base: BaseContextProperties<Mode, Data>) => ContextPropertiesWithoutBase<Mode, Data, ContextProperties> & UniquePointerContextProperties;
        setMode?: (mode: Mode) => void;
        setData?: (data: Data) => void;
        children?: React__default.ReactNode;
        InfiniteCanvasComponent?: typeof InfiniteCanvas;
    } & Omit<InfiniteCanvasProps & React__default.RefAttributes<HTMLDivElement>, "children" | "onChangeSize">, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
    ReactCanvasProvider: ({ children }: {
        children: React__default.ReactNode;
    }) => React__default.JSX.Element;
    createContextProperties: (value: ComponentProps<typeof this.Canvas>["contextProperties"]) => (base: BaseContextProperties<Mode, Data>) => ContextPropertiesWithoutBase<Mode, Data, ContextProperties> & UniquePointerContextProperties;
    getTransform: typeof getCanvasTransform;
    useTransform: () => _noya_app_noya_geometry.AffineTransform;
}
declare const ReactCanvasContext: React__default.Context<ReactCanvas<BaseMode, BaseCanvasData & PointerData, {}, ReactEventHandlerMap> | undefined>;
declare const useReactCanvas: () => ReactCanvas<BaseMode, BaseCanvasData & PointerData, {}, ReactEventHandlerMap>;
declare function createCanvas(): ReactCanvas<NoneMode, BaseCanvasData & PointerData, {}, ReactEventHandlerMap>;
type CanvasPluginsToSystem<Plugins extends AnyCanvasPlugin[]> = CanvasPluginsToSystemRecurse<never, BaseCanvasData & PointerData, {}, ReactEventHandlerMap, Plugins>;
type CanvasPluginsToSystemRecurse<Mode extends BaseMode, Data extends BaseCanvasData & PointerData, UniqueContextProperties extends object, EventHandlerMap extends ReactEventHandlerMap, Plugins extends readonly AnyCanvasPlugin[]> = Plugins extends readonly [
    Plugin<infer M, infer D, infer H, infer E>,
    ...infer Tail extends AnyCanvasPlugin[]
] ? CanvasPluginsToSystemRecurse<Mode | M, Data & D, UniqueContextProperties & Omit<H, keyof BaseContextProperties<any, any>>, EventHandlerMap & E, Tail> : PluginSystem<Mode, Data, BaseContextProperties<Mode, Data> & UniqueContextProperties, EventHandlerMap>;

type SelectMode = NoneMode;
type SelectData = {
    selectedElementIds: string[];
};
interface SelectContextProperties<CanvasElement> extends BaseContextProperties<SelectMode, SelectData>, ScreenPointProperties, ElementProperties<CanvasElement>, SelectableProperties<CanvasElement>, PointerCaptureProperties {
}
declare function selectPlugin<CanvasElement>(): {
    data: {
        size: _noya_app_noya_geometry.Size;
        zoom: number;
        origin: _noya_app_noya_geometry.Point;
    } & SelectData;
    name: string;
    handlers?: ((contextProperties: SelectContextProperties<CanvasElement> & BaseContextProperties<NoneMode, SelectData>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: SelectContextProperties<CanvasElement> & BaseContextProperties<NoneMode, SelectData>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: NoneMode | undefined;
};

type ZoomRange = [number, number];
declare function nearestLevel(zoom: number): number;
declare const Zoom: {
    min: number;
    max: number;
    range: [number, number];
    nearestLevel: typeof nearestLevel;
    clamp: (zoom: number) => number;
};

type ZoomMode = NoneMode;
type ZoomData = {
    zoom: number;
    size: Size;
    origin: Point;
};
interface ZoomContextProperties extends BaseContextProperties<ZoomMode, ZoomData>, HandleKeyboardEventProperties {
}
type ZoomPluginOptions = {
    range?: [number, number];
    onWheelShouldPreventDefault?: boolean;
    /** @default 0.02 */
    scaleFactor?: number;
};
declare function zoomPlugin(options?: ZoomPluginOptions): {
    data: {
        size: Size;
        zoom: number;
        origin: Point;
    } & {
        zoom: number;
        size: {
            width: number;
            height: number;
        };
        origin: {
            x: number;
            y: number;
        };
    };
    name: string;
    handlers?: ((contextProperties: ZoomContextProperties & BaseContextProperties<NoneMode, {
        zoom: number;
        size: {
            width: number;
            height: number;
        };
        origin: {
            x: number;
            y: number;
        };
    }>) => Partial<ReactEventHandlerMap>) | undefined;
    finalizers?: ((contextProperties: ZoomContextProperties & BaseContextProperties<NoneMode, {
        zoom: number;
        size: {
            width: number;
            height: number;
        };
        origin: {
            x: number;
            y: number;
        };
    }>) => Partial<ReactEventHandlerMap>) | undefined;
    getCursor?: ({ data, mode, }: {
        data: unknown;
        mode: unknown;
    }) => React$1.CSSProperties["cursor"] | undefined;
    __mode?: NoneMode | undefined;
};
declare function setZoom<Data extends ZoomData>(data: Data, value: number, range: ZoomRange, mode?: "replace" | "multiply" | "multiplyDiscrete"): Data;
declare function zoomIn<Data extends ZoomData>(data: Data, range: ZoomRange): Data;
declare function zoomOut<Data extends ZoomData>(data: Data, range: ZoomRange): Data;
declare function zoom0<Data extends ZoomData>(data: Data, range: ZoomRange): Data;
type ZoomAnimatedOptions<Data extends ZoomData> = {
    zoom: number;
    range: ZoomRange;
    setData: Dispatch<SetStateAction<Data>>;
    duration?: number;
    easing?: (progress: number) => number;
};
declare const defaultZoomAnimationDuration = 150;
declare const defaultZoomAnimationEasing: (progress: number) => number;
declare function zoomInAnimated<Data extends ZoomData>({ zoom, range, setData, duration, easing, }: ZoomAnimatedOptions<Data>): void;
declare function zoomOutAnimated<Data extends ZoomData>({ zoom, range, setData, duration, easing, }: ZoomAnimatedOptions<Data>): void;
declare function zoom0Animated<Data extends ZoomData>({ zoom, range, setData, duration, easing, }: ZoomAnimatedOptions<Data>): void;
declare function zoomToFit<Data extends ZoomData>({ data, rect, range, padding, }: {
    data: Data;
    rect: Rect;
    range?: ZoomRange;
    padding?: number;
}): Data;
declare function zoomToFitAnimated<Data extends ZoomData>({ data, rect, padding, range, duration, easing, setData, }: {
    data: Data;
    rect: Rect;
    padding?: number;
    range: ZoomRange;
    duration?: number;
    easing?: (progress: number) => number;
    setData: Dispatch<SetStateAction<Data>>;
}): void;

declare function easeInOut(progress: number): number;
declare function linear(progress: number): number;
declare const Easing: {
    easeInOut: typeof easeInOut;
    linear: typeof linear;
};
declare function animateValue({ start, end, duration, easing, onChange, }: {
    start: number;
    end: number;
    duration: number;
    easing?: (progress: number) => number;
    onChange: (value: number) => void;
}): () => void;

type DragHandle = {
    rect: Rect;
    compassDirection: CompassDirection;
    offset: Point;
    strokeWidth: number;
};
declare function getDragHandles({ selectionRect, data: { zoom, dragHandleSize }, }: {
    selectionRect: Rect;
    data: Pick<ScaleData, "zoom" | "dragHandleSize">;
}): DragHandle[];
type PointHandle = {
    rect: Rect;
    strokeWidth: number;
    id: string;
};
declare function getPointHandles({ points, data: { zoom, pointHandleSize }, }: {
    points: IdentifiablePoint[];
    data: Pick<PointData, "zoom" | "pointHandleSize">;
}): PointHandle[];

declare function filterElements<CanvasElement extends {
    rect: Rect;
}>(elements: CanvasElement[], options: GetElementsOptions<CanvasElement>): CanvasElement[];
declare function filterElements<CanvasElement>(elements: CanvasElement[], getRect: (element: CanvasElement) => Rect, options: GetElementsOptions<CanvasElement>): CanvasElement[];
type TransformDraftElementsOptions<CanvasElement extends {
    id: string;
}> = {
    draftElements: CanvasElement[];
    snapshotElements: CanvasElement[];
    transform: AffineTransform;
    minimumElementSize?: Size | number | false;
    preserveAspectRatio?: boolean;
    normalizeNegativeScale?: boolean;
};
type TransformableElementOptions<CanvasElement> = {
    updateElement: (element: CanvasElement, newProps: {
        rect: Rect;
        flip: {
            x: boolean;
            y: boolean;
        };
    }) => void;
    getRect: (element: CanvasElement) => Rect;
};
declare function transformDraftElements<CanvasElement extends {
    id: string;
}>(options: TransformDraftElementsOptions<CanvasElement> & TransformableElementOptions<CanvasElement>): void;
declare function transformDraftElements<CanvasElement extends {
    id: string;
    rect: Rect;
}>(options: TransformDraftElementsOptions<CanvasElement>): void;
declare function getSelectionRect<CanvasElement extends {
    rect: Rect;
}>(elements: CanvasElement[]): Rect | undefined;
declare function getSelectionRect<CanvasElement>(elements: CanvasElement[], getRect: (element: CanvasElement) => Rect): Rect | undefined;
declare function applyFlip<P extends Point>(point: P, flip: {
    x: boolean;
    y: boolean;
}): P;

type ReactDOMEventHandlers = {
    onMouseDown?: React.MouseEventHandler;
    onMouseDownCapture?: React.MouseEventHandler;
    onMouseEnter?: React.MouseEventHandler;
    onMouseLeave?: React.MouseEventHandler;
    onMouseMove?: React.MouseEventHandler;
    onMouseMoveCapture?: React.MouseEventHandler;
    onMouseOut?: React.MouseEventHandler;
    onMouseOutCapture?: React.MouseEventHandler;
    onMouseOver?: React.MouseEventHandler;
    onMouseOverCapture?: React.MouseEventHandler;
    onMouseUp?: React.MouseEventHandler;
    onMouseUpCapture?: React.MouseEventHandler;
    onTouchCancel?: React.TouchEventHandler;
    onTouchCancelCapture?: React.TouchEventHandler;
    onTouchEnd?: React.TouchEventHandler;
    onTouchEndCapture?: React.TouchEventHandler;
    onTouchMove?: React.TouchEventHandler;
    onTouchMoveCapture?: React.TouchEventHandler;
    onTouchStart?: React.TouchEventHandler;
    onTouchStartCapture?: React.TouchEventHandler;
    onPointerDown?: React.PointerEventHandler;
    onPointerDownCapture?: React.PointerEventHandler;
    onPointerMove?: React.PointerEventHandler;
    onPointerMoveCapture?: React.PointerEventHandler;
    onPointerUp?: React.PointerEventHandler;
    onPointerUpCapture?: React.PointerEventHandler;
    onPointerCancel?: React.PointerEventHandler;
    onPointerCancelCapture?: React.PointerEventHandler;
    onPointerEnter?: React.PointerEventHandler;
    onPointerEnterCapture?: React.PointerEventHandler;
    onPointerLeave?: React.PointerEventHandler;
    onPointerLeaveCapture?: React.PointerEventHandler;
    onPointerOver?: React.PointerEventHandler;
    onPointerOverCapture?: React.PointerEventHandler;
    onPointerOut?: React.PointerEventHandler;
    onPointerOutCapture?: React.PointerEventHandler;
    onGotPointerCapture?: React.PointerEventHandler;
    onGotPointerCaptureCapture?: React.PointerEventHandler;
    onLostPointerCapture?: React.PointerEventHandler;
    onLostPointerCaptureCapture?: React.PointerEventHandler;
    onScroll?: React.UIEventHandler;
    onScrollCapture?: React.UIEventHandler;
    onWheel?: React.WheelEventHandler;
    onWheelCapture?: React.WheelEventHandler;
    onClick?: React.MouseEventHandler;
    onClickCapture?: React.MouseEventHandler;
    onKeyDown?: (e: React.KeyboardEvent) => void;
    onKeyDownCapture?: (e: React.KeyboardEvent) => void;
    onKeyUp?: (e: React.KeyboardEvent) => void;
    onKeyUpCapture?: (e: React.KeyboardEvent) => void;
    onKeyPress?: (e: React.KeyboardEvent) => void;
    onKeyPressCapture?: (e: React.KeyboardEvent) => void;
    onBeforeInput?: (e: InputEvent) => void;
};

declare const DEFAULT_MOVEMENT_THRESHOLD = 2;
declare function isMoving(current: Point, origin: Point, zoomValue: number, threshold: number): boolean;

declare function isLeftButtonClicked(event: React.MouseEvent): boolean;
declare function isRightButtonClicked(event: React.MouseEvent): boolean;

type SelectionType = "replace" | "intersection" | "difference" | "symmetricDifference";
declare function updateSelection<T extends string | number>(currentIds: T[], newIds: T | T[] | undefined, selectionType: SelectionType): void;
declare function makeSelection(a: string[], b: string[], selectionType: SelectionType): string[];
declare function updateSelectionWithItem(selection: string[], elementId: string | undefined, shiftKey: boolean): string[];

type AddParameter<T extends (...args: any[]) => any, P> = (arg: P, ...args: Parameters<T>) => ReturnType<T>;
type AddParameterToMapping<T extends Record<string, (...args: any[]) => any>, P> = {
    [K in keyof T]: AddParameter<T[K], P>;
};

type GetViewportOriginOptions = {
    data: BaseCanvasData;
    rect: Rect;
    /** percentage of overlap to consider as "within viewport" */
    overlapThreshold?: number;
} & Omit<CreateResizeTransformOptions, "resizePosition">;
declare function getViewportOriginContainingRect({ data, rect: rectToContain, overlapThreshold, ...options }: GetViewportOriginOptions): {
    x: number;
    y: number;
};
declare function isRectInViewport({ data, rect: rectToContain, fractionOfRectVisible, }: {
    data: BaseCanvasData;
    rect: Rect;
    fractionOfRectVisible?: number;
}): boolean;

declare function wheelValues(event: WheelEvent): Point;

export { type AddParameter, type AddParameterToMapping, type AnyCanvasPlugin, type AnyCanvasPluginSystem, type AnyPlugin, type AnyPluginSystem, type BaseCanvasData, type BaseContextProperties, type BaseEventHandlerMap, type BaseMode, type CanvasPluginsToSystem, type CanvasRefProperties, DEFAULT_DRAG_HANDLE_SIZE, DEFAULT_GRADIENT_HANDLE_SIZE, DEFAULT_MOVEMENT_THRESHOLD, DEFAULT_POINT_HANDLE_SIZE, type DOMContextProperties, type DomTextPluginOptions, type DragHandle, DragHandles, type DuplicateElementsResult, Easing, type EditTextData, type EditTextMode, type EditTextPluginOptions, type EditingTextMode, type ElementProperties, type EraserContextProperties, type EraserData, type EraserMode, type EventWithPointAndTarget, type FocusContextContext, type FocusData, type FocusMode, type FocusProperties, GRADIENT_EDITOR_SURFACE_ATTRIBUTE, type GetCursorUnknown, type GetElementsOptions, type GetPointsOptions, type GradientEditorContextProperties, type GradientEditorData, type GradientEditorDetails, type GradientEditorGradient, type GradientEditorLinearGradient, type GradientEditorMode, type GradientEditorPluginOptions, GradientHandles, type GradientStopHandle, type HandleKeyboardEventProperties, type HandlerMap, type HighlightContextProperties, type HighlightData, type HighlightMode, type HighlightableProperties, type IdentifiablePoint, InfiniteCanvas, type InfiniteCanvasProps, type LineContextProperties, type LineData, type LineHandleCoordinates, type LinePluginOptions, Marquee, type MarqueeData, type MarqueeHandlerContext, type MarqueeMode, type MarqueePluginMode, type MarqueePluginOptions, type ModeHandlerMap, type MovableProperties, type MoveContextProperties, type MoveData, type MoveElementParameters, type MoveMode, type MovePluginOptions, type MovingOptions, type NoneMode, type PanContextProperties, type PanData, type PanMode, type PanOptions, type Plugin, type PluginContextProperties, type PluginData, type PluginEventHandlerMap, type PluginMode, PluginSystem, type PluginSystemContextProperties, type PluginSystemData, type PluginSystemEventHandlerMap, type PluginSystemMode, type PluginSystemOptions, type PluginsToSystem, type PointData, PointHandles, type PointHighlightableProperties, type PointProperties, type PointerCaptureProperties, type PointerContextProperties, type PointerData, ReactCanvas, ReactCanvasContext, type ReactDOMEventHandlers, type ReactEventHandlerMap, type ScalableProperties, type ScaleContextProperties, type ScaleData, type ScaleElementParameters, type ScaleMode, type ScalePluginOptions, type ScalingOptions, type ScalingOriginMode, type ScreenPointProperties, type SelectContextProperties, type SelectData, type SelectMode, type SelectableProperties, type SelectionPoint, type SelectionRange, SelectionRect, type SelectionType, type SnapLine, SnapLines, TEXT_SELECTION_PATH, type TextEditElement, type TextEditableProperties, type TextMeasurement, UnhandledSymbol, type UniquePointerContextProperties, Zoom, type ZoomAnimatedOptions, type ZoomContextProperties, type ZoomData, type ZoomMode, type ZoomPluginOptions, type ZoomRange, animateValue, applyFlip, convertOffsetPoint, convertPoint, createCanvas, createCanvasPlugin, createGradientEditorDetails, defaultZoomAnimationDuration, defaultZoomAnimationEasing, domEventPlugin, domTextPlugin, doubleClickPlugin, drawingPlugin, editTextPlugin, eraserPlugin, filterElements, focusPlugin, getAbsolutizeTransform, getBestSnapDelta, getCanvasTransform, getDragHandles, getElementSnapDelta, getGridSnapDelta, getMoveSnapDelta, getMoveTransform, getMovingOptionsForEvent, getNormalizeTransform, getPointHandles, getRectExtentPoint, getScaleSnapDelta, getScaleTransform, getScalingOptionsForEvent, getSelectionRect, getSnapLines, getValuesOnAxis, getViewportOriginContainingRect, gradientEditorPlugin, highlightPlugin, initialBaseCanvasData, initialPointerData, isLeftButtonClicked, isMarqueeMode, isMoving, isRectInViewport, isRightButtonClicked, linePlugin, makeSelection, marqueePlugin, modeSwitch, movePlugin, offsetRangeToSelection, panPlugin, pointPlugin, pointerPlugin, scalePlugin, selectPlugin, selectionToOffsetRange, setZoom, transformDraftElements, updateSelection, updateSelectionWithItem, useGradientEditor, useMultipleClickCount, useReactCanvas, wheelValues, zoom0, zoom0Animated, zoomIn, zoomInAnimated, zoomOut, zoomOutAnimated, zoomPlugin, zoomToFit, zoomToFitAnimated };