//#region src/types.d.ts
interface Point {
  x: number;
  y: number;
}
interface Size {
  width: number;
  height: number;
}
interface BoundingBox {
  x: number;
  y: number;
  width: number;
  height: number;
}
type ElementId = string;
type ElementType = "rectangle" | "ellipse" | "star" | "line" | "path" | "media" | "group";
interface BaseElement {
  id: ElementId;
  type: ElementType;
  x: number;
  y: number;
  width: number;
  height: number;
  rotation: number;
  zIndex: number;
  locked: boolean;
  visible: boolean;
}
interface RectangleElement extends BaseElement {
  type: "rectangle";
  cornerRadius: number;
}
interface EllipseElement extends BaseElement {
  type: "ellipse";
}
interface LineElement extends BaseElement {
  type: "line";
  startX: number;
  startY: number;
  endX: number;
  endY: number;
  strokeWidth: number;
  strokeColor: string;
}
interface PathElement extends BaseElement {
  type: "path";
  points: Point[];
  strokeWidth: number;
  strokeColor: string;
  smoothing?: number;
}
interface MediaElement extends BaseElement {
  type: "media";
  src: string;
  mimeType: string;
  naturalWidth: number;
  naturalHeight: number;
}
interface GroupElement extends BaseElement {
  type: "group";
  children: ElementId[];
}
type CanvasElement = RectangleElement | EllipseElement | LineElement | PathElement | MediaElement | GroupElement;
type ToolType = "select" | "hand" | "draw" | "eraser" | "rectangle" | "ellipse" | "line" | "media";
interface ViewportState {
  x: number;
  y: number;
  zoom: number;
}
interface CanvasConfig {
  snapEnabled: boolean;
  snapThreshold: number;
  gridEnabled: boolean;
  gridSize: number;
  minZoom: number;
  maxZoom: number;
}
interface CanvasState {
  elements: Map<ElementId, CanvasElement>;
  selectedIds: Set<ElementId>;
  viewport: ViewportState;
  activeTool: ToolType;
}
interface CanvasElementStyle {
  strokeColor?: string;
  fillColor?: string;
  strokeWidth?: number;
  opacity?: number;
}
interface Transform {
  translate: Point;
  scale: Point;
  rotation: number;
}
interface SnapGuide {
  type: "horizontal" | "vertical";
  position: number;
  elements: ElementId[];
}
interface SnapResult {
  guides: SnapGuide[];
  snapped: boolean;
}
type ResizeAnchor = "top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center" | "left-center" | "right-center" | "center";
//#endregion
//#region src/snapping.d.ts
interface SnappingConfig {
  enabled: boolean;
  threshold: number;
}
declare function createSnappingConfig(partial?: Partial<SnappingConfig>): SnappingConfig;
interface SnapPoint {
  x: number;
  y: number;
  elementId: ElementId;
  type: "left" | "right" | "top" | "bottom" | "center-x" | "center-y";
}
declare function getElementSnapPoints(element: CanvasElement): SnapPoint[];
declare function getAllSnapPoints(elements: Map<ElementId, CanvasElement>, excludeIds?: Set<string>): SnapPoint[];
declare function calculateSnap(point: Point, snapPoints: SnapPoint[], threshold: number): SnapResult;
declare function snapPointToGuides(point: Point, guides: SnapGuide[]): Point;
declare function snapBoundsToElements(bounds: {
  x: number;
  y: number;
  width: number;
  height: number;
}, elements: Map<ElementId, CanvasElement>, excludeIds: Set<ElementId>, threshold: number): {
  x: number;
  y: number;
  width: number;
  height: number;
  guides: SnapGuide[];
};
//#endregion
//#region src/canvas.d.ts
interface CanvasOptions {
  snapping?: Partial<SnappingConfig>;
  initialViewport?: ViewportState;
  hideOverlayWhileTransforming?: boolean;
}
interface AdrawCanvasOptions extends CanvasOptions {
  container?: HTMLElement;
}
interface CanvasEventMap {
  change: {
    elements: Map<ElementId, CanvasElement>;
  };
  viewportChange: {
    viewport: ViewportState;
  };
  toolChange: {
    tool: ToolType;
  };
  selectionChange: {
    selectedIds: Set<ElementId>;
  };
}
type EventListener<K extends keyof CanvasEventMap> = (event: CanvasEventMap[K]) => void;
declare function pointsToPath(points: Point[], tension?: number): string;
declare function createElementGroup(element: CanvasElement): SVGGElement;
declare class AdrawCanvas {
  private elements;
  private selectedIds;
  private viewport;
  private activeTool;
  private snappingConfig;
  private hideOverlayWhileTransforming;
  private history;
  private listeners;
  private canvasSize;
  private tools;
  private container;
  private svgElement;
  private elementsGroup;
  private temporaryNode;
  private temporaryType;
  private guidesGroup;
  private transformOverlay;
  private overlayNodes;
  private selectionBoxNode;
  private resizeObserver;
  private pinchStartDistance;
  private pinchStartCenter;
  private pinchViewportState;
  constructor(options?: AdrawCanvasOptions);
  private getToolContext;
  setCanvasSize(width: number, height: number): void;
  setActiveTool(toolType: ToolType): void;
  getActiveTool(): ToolType;
  getViewport(): ViewportState;
  setViewport(viewport: ViewportState): void;
  getElements(): Map<ElementId, CanvasElement>;
  getSelectedIds(): Set<ElementId>;
  getSnappingConfig(): SnappingConfig;
  setSnappingConfig(config: Partial<SnappingConfig>): void;
  getHideOverlayWhileTransforming(): boolean;
  setHideOverlayWhileTransforming(hide: boolean): void;
  canUndo(): boolean;
  canRedo(): boolean;
  undo(): boolean;
  redo(): boolean;
  handlePointerDown(screenX: number, screenY: number, event: PointerEvent): void;
  handlePointerMove(screenX: number, screenY: number, event: PointerEvent): void;
  handlePointerUp(screenX: number, screenY: number, event: PointerEvent): void;
  handleWheel(event: WheelEvent, screenX?: number, screenY?: number): void;
  handleKeyDown(event: KeyboardEvent): void;
  selectAll(): void;
  clearSelection(): void;
  deleteSelected(): void;
  zoomIn(): void;
  zoomOut(): void;
  resetZoom(): void;
  zoomToFit(): void;
  getTemporaryElement(): CanvasElement | null;
  on<K extends keyof CanvasEventMap>(event: K, listener: EventListener<K>): void;
  off<K extends keyof CanvasEventMap>(event: K, listener: EventListener<K>): void;
  private emit;
  mount(container: HTMLElement): void;
  private init;
  private getRelativePoint;
  private setupEventListeners;
  private handleTouchEnd;
  private updateCursor;
  render(): void;
  private renderSelectionBox;
  private ensureOverlayNodes;
  private renderTransformOverlay;
  private reconcileElements;
  private renderTemporary;
  private updateElementGeometry;
  private renderSelectElements;
  destroy(): void;
}
//#endregion
//#region src/coordinates.d.ts
declare function screenToCanvas(screenPoint: Point, viewport: ViewportState, canvasSize: Size): Point;
declare function canvasToScreen(canvasPoint: Point, viewport: ViewportState, canvasSize: Size): Point;
declare function getElementBounds(x: number, y: number, width: number, height: number, rotation?: number): {
  left: number;
  right: number;
  top: number;
  bottom: number;
  center: Point;
};
declare function pointInBounds(point: Point, bounds: {
  left: number;
  right: number;
  top: number;
  bottom: number;
}): boolean;
declare function distanceBetweenPoints(p1: Point, p2: Point): number;
declare function clamp(value: number, min: number, max: number): number;
declare function generateId(): string;
//#endregion
//#region src/elements.d.ts
type ElementFactory<T extends CanvasElement> = Omit<T, "id" | "type"> & {
  id?: string;
};
declare const DEFAULT_PATH_SMOOTHING = 0.5;
declare function createRectangle(factory: ElementFactory<RectangleElement>): RectangleElement;
declare function createEllipse(factory: ElementFactory<EllipseElement>): EllipseElement;
declare function createLine(factory: ElementFactory<LineElement>): LineElement;
declare function createPath(factory: ElementFactory<PathElement>): PathElement;
declare function createMedia(factory: ElementFactory<MediaElement>): MediaElement;
declare function createGroup(factory: ElementFactory<GroupElement>): GroupElement;
declare function cloneElement<T extends CanvasElement>(element: T, offset?: Point): T;
declare function moveElement(element: CanvasElement, delta: Point): CanvasElement;
declare function resizeElement(element: CanvasElement, width: number, height: number, anchor?: ResizeAnchor): CanvasElement;
declare function rotateElement(element: CanvasElement, rotation: number): CanvasElement;
declare function getElementsBounds(elements: Map<ElementId, CanvasElement>, ids?: Set<ElementId>): {
  left: number;
  right: number;
  top: number;
  bottom: number;
  x: number;
  y: number;
  width: number;
  height: number;
} | null;
declare function getElementAtPoint(elements: Map<ElementId, CanvasElement>, point: Point): CanvasElement | null;
//#endregion
//#region src/history.d.ts
interface HistoryEntry {
  elements: Map<ElementId, CanvasElement>;
  selectedIds: Set<ElementId>;
  timestamp: number;
}
interface HistoryState {
  undoStack: HistoryEntry[];
  redoStack: HistoryEntry[];
  maxSize: number;
}
declare function createHistoryState(maxSize?: number): HistoryState;
declare function pushHistory(state: HistoryState, elements: Map<ElementId, CanvasElement>, selectedIds: Set<ElementId>): HistoryState;
declare function undo(state: HistoryState, currentElements: Map<ElementId, CanvasElement>, currentSelectedIds: Set<ElementId>): {
  state: HistoryState;
  elements: Map<ElementId, CanvasElement>;
  selectedIds: Set<ElementId>;
} | null;
declare function redo(state: HistoryState, _currentElements: Map<ElementId, CanvasElement>, _currentSelectedIds: Set<ElementId>): {
  state: HistoryState;
  elements: Map<ElementId, CanvasElement>;
  selectedIds: Set<ElementId>;
} | null;
declare function canUndo(state: HistoryState): boolean;
declare function canRedo(state: HistoryState): boolean;
declare function clearHistory(state: HistoryState): HistoryState;
//#endregion
//#region src/tools/base.d.ts
interface ToolContext {
  getElements: () => Map<ElementId, CanvasElement>;
  setElements: (elements: Map<ElementId, CanvasElement>) => void;
  getSelectedIds: () => Set<ElementId>;
  setSelectedIds: (ids: Set<ElementId>) => void;
  getViewport: () => ViewportState;
  setViewport: (viewport: ViewportState) => void;
  getCanvasSize: () => {
    width: number;
    height: number;
  };
  pushHistory: () => void;
  setActiveTool: (tool: ToolType) => void;
}
interface Tool {
  readonly type: ToolType;
  readonly cursor: string;
  onActivate: (context: ToolContext) => void;
  onDeactivate: (context: ToolContext) => void;
  onPointerDown: (context: ToolContext, point: Point, event: PointerEvent) => void;
  onPointerMove: (context: ToolContext, point: Point, event: PointerEvent) => void;
  onPointerUp: (context: ToolContext, point: Point, event: PointerEvent) => void;
  getTemporaryElement: () => CanvasElement | null;
  getSelectionBox?: () => BoundingBox | null;
  isResizing?: () => boolean;
  isRotating?: () => boolean;
}
interface ToolOptions {
  strokeColor?: string;
  fillColor?: string;
  strokeWidth?: number;
}
//#endregion
//#region src/tools/draw.d.ts
interface DrawToolOptions extends ToolOptions {
  smoothing?: number;
}
declare function createDrawTool(options?: DrawToolOptions): Tool;
//#endregion
//#region src/tools/ellipse.d.ts
declare function createEllipseTool(): Tool;
//#endregion
//#region src/tools/eraser.d.ts
declare function createEraserTool(): Tool;
//#endregion
//#region src/tools/hand.d.ts
declare function createHandTool(): Tool;
//#endregion
//#region src/tools/line.d.ts
declare function createLineTool(options?: ToolOptions): Tool;
//#endregion
//#region src/tools/media.d.ts
interface MediaToolOptions {
  maxWidth?: number;
  maxHeight?: number;
}
declare function createMediaTool(options?: MediaToolOptions): Tool;
interface MediaTool extends Tool {
  addMedia(src: string, mimeType: string): void;
}
//#endregion
//#region src/tools/rectangle.d.ts
interface RectangleToolOptions extends ToolOptions {
  cornerRadius?: number;
}
declare function createRectangleTool(options?: RectangleToolOptions): Tool;
//#endregion
//#region src/tools/select.d.ts
interface SelectToolOptions {
  multiSelectModifier: "shift" | "ctrl";
}
declare function createSelectTool(options?: SelectToolOptions): Tool;
//#endregion
//#region src/viewport.d.ts
interface ViewportConfig {
  minZoom: number;
  maxZoom: number;
  zoomSensitivity: number;
}
declare function createViewport(initialViewport?: ViewportState, config?: Partial<ViewportConfig>): ViewportState;
declare function panViewport(viewport: ViewportState, delta: Point, _config?: ViewportConfig): ViewportState;
declare function zoomViewport(viewport: ViewportState, delta: number, centerPoint: Point, config?: ViewportConfig): ViewportState;
declare function zoomToFit(viewport: ViewportState, bounds: {
  left: number;
  right: number;
  top: number;
  bottom: number;
}, canvasSize: {
  width: number;
  height: number;
}, padding?: number): ViewportState;
declare function resetViewport(): ViewportState;
//#endregion
export { AdrawCanvas, AdrawCanvasOptions, BaseElement, BoundingBox, CanvasConfig, CanvasElement, CanvasElementStyle, CanvasEventMap, CanvasOptions, CanvasState, DEFAULT_PATH_SMOOTHING, type DrawToolOptions, ElementFactory, ElementId, ElementType, EllipseElement, GroupElement, HistoryEntry, HistoryState, LineElement, MediaElement, type MediaTool, type MediaToolOptions, PathElement, Point, RectangleElement, type RectangleToolOptions, ResizeAnchor, type SelectToolOptions, Size, SnapGuide, SnapPoint, SnapResult, SnappingConfig, ToolType, Transform, ViewportConfig, ViewportState, calculateSnap, canRedo, canUndo, canvasToScreen, clamp, clearHistory, cloneElement, createDrawTool, createElementGroup, createEllipse, createEllipseTool, createEraserTool, createGroup, createHandTool, createHistoryState, createLine, createLineTool, createMedia, createMediaTool, createPath, createRectangle, createRectangleTool, createSelectTool, createSnappingConfig, createViewport, distanceBetweenPoints, generateId, getAllSnapPoints, getElementAtPoint, getElementBounds, getElementSnapPoints, getElementsBounds, moveElement, panViewport, pointInBounds, pointsToPath, pushHistory, redo, resetViewport, resizeElement, rotateElement, screenToCanvas, snapBoundsToElements, snapPointToGuides, undo, zoomToFit, zoomViewport };
//# sourceMappingURL=index.d.cts.map