pointrix 1.0.0

package/dist/pointrix.d.cts

@@ -0,0 +1,784 @@
+//#region src/nano.d.ts
+interface Point {
+  x: number;
+  y: number;
+}
+interface PointerState {
+  id: number;
+  start: Point;
+  current: Point;
+  previous: Point;
+  delta: Point;
+  total: Point;
+  velocity: Point;
+  timestamp: number;
+}
+interface InteractionEvent {
+  target: HTMLElement;
+  pointers: PointerState[];
+  isPrimary: boolean;
+  originalEvent: PointerEvent;
+}
+interface GripOptions {
+  onStart?: (event: InteractionEvent) => void;
+  onMove?: (event: InteractionEvent) => void;
+  onEnd?: (event: InteractionEvent) => void;
+  onTap?: (event: InteractionEvent) => void;
+  onDoubleTap?: (event: InteractionEvent) => void;
+  onHold?: (event: InteractionEvent) => void;
+  threshold?: number;
+  preventScroll?: boolean;
+  holdDelay?: number;
+  holdDuration?: number;
+  mouseButtons?: number;
+  allowFrom?: string;
+  ignoreFrom?: string;
+  touchAction?: string;
+  styleCursor?: boolean;
+}
+declare class Grip {
+  protected element: HTMLElement;
+  protected options: GripOptions;
+  protected pointers: Map<number, PointerState>;
+  private pointersCache;
+  protected isActive: boolean;
+  protected lastUpdate: number;
+  protected priority: number;
+  private _enabled;
+  private holdTimer;
+  private holdEventTimer;
+  private lastTapTime;
+  private lastTapTarget;
+  private listeners;
+  on(event: string, handler: Function): this;
+  off(event: string, handler: Function): this;
+  protected emit(event: string, data: any): void;
+  get enabled(): boolean;
+  set enabled(value: boolean);
+  get interacting(): boolean;
+  private static elementInstances;
+  private static activeInstance;
+  private static elementListeners;
+  constructor(element: HTMLElement, options?: GripOptions);
+  private registerInstance;
+  private unregisterInstance;
+  protected shouldHandleEvent(_e: PointerEvent): boolean;
+  private checkEventFilters;
+  private static handleElementPointerDown;
+  private onPointerDown;
+  private handlePointerDown;
+  private onPointerMove;
+  private onPointerUp;
+  private start;
+  private end;
+  update(): void;
+  hasActivePointers(): boolean;
+  private createEvent;
+  destroy(): void;
+}
+declare function grip(element: HTMLElement | string, options?: GripOptions): Grip;
+//#endregion
+//#region src/types.d.ts
+interface Point$2 {
+  x: number;
+  y: number;
+}
+interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface ActiveEdges {
+  top: boolean;
+  right: boolean;
+  bottom: boolean;
+  left: boolean;
+}
+interface ModifierContext {
+  position: Point$2;
+  velocity: Point$2;
+  element: HTMLElement;
+  startPosition: Point$2;
+  delta: Point$2;
+  edges?: ActiveEdges;
+  size?: {
+    width: number;
+    height: number;
+  };
+  startSize?: {
+    width: number;
+    height: number;
+  };
+}
+interface ModifierResult {
+  position: Point$2;
+  velocity: Point$2;
+  size?: {
+    width: number;
+    height: number;
+  };
+}
+interface Modifier {
+  name: string;
+  onStart?(context: ModifierContext): void;
+  modify(context: ModifierContext): ModifierResult;
+  onEnd?(context: ModifierContext): ModifierResult | void;
+}
+declare function applyModifiers(modifiers: Modifier[], context: ModifierContext): ModifierResult;
+//#endregion
+//#region src/drag.d.ts
+interface DragOptions extends GripOptions {
+  /** Enable ARIA attributes for accessibility (default: true) */
+  aria?: boolean;
+  axis?: 'x' | 'y' | 'xy' | 'start';
+  startAxis?: 'x' | 'y';
+  handle?: string | HTMLElement;
+  bounds?: 'parent' | HTMLElement | {
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+  };
+  grid?: {
+    x: number;
+    y: number;
+  };
+  momentum?: boolean | {
+    friction?: number;
+    minSpeed?: number;
+  };
+  modifiers?: Modifier[];
+  droppable?: boolean;
+  cursorChecker?: (action: 'idle' | 'grab' | 'grabbing') => string;
+  onDragStart?: (event: DragEvent) => void;
+  onDragMove?: (event: DragEvent) => void;
+  onDragEnd?: (event: DragEvent) => void;
+}
+interface DragEvent extends InteractionEvent {
+  dx: number;
+  dy: number;
+  totalX: number;
+  totalY: number;
+  velocityX: number;
+  velocityY: number;
+}
+declare class Draggable extends Grip {
+  private dragOptions;
+  private transform;
+  private startTransform;
+  private bounds;
+  private momentum;
+  private transformNormalized;
+  private detectedAxis;
+  private startAxisConfirmed;
+  private cachedSize;
+  private modifierContext;
+  private cachedDragEvent;
+  constructor(element: HTMLElement, options?: DragOptions);
+  protected shouldHandleEvent(e: PointerEvent): boolean;
+  private readCurrentTransform;
+  private handleDragStart;
+  private handleDragMove;
+  private handleDragEnd;
+  private startMomentum;
+  private applyTransform;
+  private createDragEvent;
+  setPosition(x: number, y: number): void;
+  getPosition(): {
+    x: number;
+    y: number;
+  };
+  destroy(): void;
+}
+declare function draggable(element: HTMLElement | string, options?: DragOptions): Draggable;
+//#endregion
+//#region src/resize.d.ts
+interface ResizeOptions extends GripOptions {
+  edges?: {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+  };
+  handleSize?: number;
+  minWidth?: number;
+  minHeight?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  aspectRatio?: number | 'preserve';
+  square?: boolean;
+  invert?: 'none' | 'negate' | 'reposition';
+  grid?: {
+    width: number;
+    height: number;
+  };
+  modifiers?: Modifier[];
+  cursorChecker?: (edge: string | null) => string;
+  onResizeStart?: (event: ResizeEvent) => void;
+  onResizeMove?: (event: ResizeEvent) => void;
+  onResizeEnd?: (event: ResizeEvent) => void;
+}
+interface ResizeEvent extends InteractionEvent {
+  width: number;
+  height: number;
+  deltaWidth: number;
+  deltaHeight: number;
+  edges: {
+    top: boolean;
+    right: boolean;
+    bottom: boolean;
+    left: boolean;
+  };
+}
+declare class Resizable extends Grip {
+  private resizeOptions;
+  private startSize;
+  private startPos;
+  private currentSize;
+  private currentPos;
+  private activeEdge;
+  private edgeFlags;
+  private aspectRatio;
+  private boundUpdateCursor;
+  private transformNormalized;
+  private modifierContext;
+  private cachedResizeEvent;
+  constructor(element: HTMLElement, options?: ResizeOptions);
+  private normalizeInitialTransform;
+  protected shouldHandleEvent(e: PointerEvent): boolean;
+  private updateCursor;
+  private detectEdge;
+  private getCursor;
+  private handleResizeStart;
+  private handleResizeMove;
+  private handleResizeEnd;
+  private createResizeEvent;
+  setSize(width: number, height: number): void;
+  getSize(): {
+    width: number;
+    height: number;
+  };
+  destroy(): void;
+}
+declare function resizable(element: HTMLElement | string, options?: ResizeOptions): Resizable;
+//#endregion
+//#region src/gesture.d.ts
+interface GestureEvent extends InteractionEvent {
+  scale: number;
+  rotation: number;
+  distance: number;
+  angle: number;
+  center: Point;
+  deltaScale: number;
+  deltaAngle: number;
+}
+interface GestureOptions extends GripOptions {
+  minPointers?: number;
+  onGestureStart?: (event: GestureEvent) => void;
+  onGestureMove?: (event: GestureEvent) => void;
+  onGestureEnd?: (event: GestureEvent) => void;
+}
+declare class Gesturable extends Grip {
+  private gestureOptions;
+  private gestureActive;
+  private startDistance;
+  private startAngle;
+  private prevScale;
+  private prevAngle;
+  private minPointers;
+  constructor(element: HTMLElement, options?: GestureOptions);
+  protected shouldHandleEvent(_e: PointerEvent): boolean;
+  private getTwoPointers;
+  private computeDistance;
+  private computeAngle;
+  private computeCenter;
+  private normalizeAngleDelta;
+  private createGestureEvent;
+  update(): void;
+  private endGesture;
+  destroy(): void;
+}
+declare function gesturable(element: HTMLElement | string, options?: GestureOptions): Gesturable;
+//#endregion
+//#region src/dropzone.d.ts
+interface DropEvent {
+  target: HTMLElement;
+  draggable: HTMLElement;
+  dragEvent?: DragEvent;
+  overlap: number;
+}
+interface DropzoneOptions {
+  accept?: string | ((draggable: HTMLElement) => boolean);
+  overlap?: 'pointer' | 'center' | number;
+  activeClass?: string;
+  hoverClass?: string;
+  /** Enable ARIA attributes (default: true) */
+  aria?: boolean;
+  onActivate?: (event: DropEvent) => void;
+  onDeactivate?: (event: DropEvent) => void;
+  onDragEnter?: (event: DropEvent) => void;
+  onDragLeave?: (event: DropEvent) => void;
+  onDragOver?: (event: DropEvent) => void;
+  onDrop?: (event: DropEvent) => void;
+}
+interface Point$1 {
+  x: number;
+  y: number;
+}
+declare class Dropzone {
+  readonly element: HTMLElement;
+  private options;
+  private _isOver;
+  private _isActive;
+  private _enabled;
+  private listeners;
+  on(event: string, handler: Function): this;
+  off(event: string, handler: Function): this;
+  private emit;
+  get enabled(): boolean;
+  set enabled(value: boolean);
+  constructor(element: HTMLElement, options?: DropzoneOptions);
+  get isOver(): boolean;
+  get isActive(): boolean;
+  accepts(draggableEl: HTMLElement): boolean;
+  checkOverlap(draggableEl: HTMLElement, pointerPos: Point$1): number;
+  activate(draggableEl: HTMLElement): void;
+  deactivate(draggableEl: HTMLElement): void;
+  enter(draggableEl: HTMLElement, overlap: number, dragEvent?: DragEvent): void;
+  leave(draggableEl: HTMLElement, dragEvent?: DragEvent): void;
+  over(draggableEl: HTMLElement, overlap: number, dragEvent?: DragEvent): void;
+  drop(draggableEl: HTMLElement, overlap: number, dragEvent?: DragEvent): void;
+  private createEvent;
+  updateOptions(options: Partial<DropzoneOptions>): void;
+  destroy(): void;
+}
+declare class DropzoneManagerSingleton {
+  private zones;
+  register(zone: Dropzone): void;
+  unregister(zone: Dropzone): void;
+  onDragStart(draggableEl: HTMLElement): void;
+  onDragMove(draggableEl: HTMLElement, pointerPos: Point$1, dragEvent?: DragEvent): void;
+  onDragEnd(draggableEl: HTMLElement, pointerPos: Point$1, dragEvent?: DragEvent): void;
+  getActiveZones(): Dropzone[];
+  getHoveredZones(): Dropzone[];
+}
+declare const DropzoneManager: DropzoneManagerSingleton;
+declare function dropzone(element: HTMLElement | string, options?: DropzoneOptions): Dropzone;
+//#endregion
+//#region src/sortable.d.ts
+interface SortableOptions {
+  /** Enable ARIA attributes for accessibility (default: true) */
+  aria?: boolean;
+  /** CSS selector for draggable items within the container (default: direct children) */
+  items?: string;
+  /** Axis of sorting: 'y' for vertical lists, 'x' for horizontal (default: 'y') */
+  axis?: 'x' | 'y';
+  /** CSS selector for drag handle within each item (optional) */
+  handle?: string;
+  /** Animation duration in ms for items shifting out of the way (default: 200) */
+  animationDuration?: number;
+  /** CSS class added to the item being dragged */
+  dragClass?: string;
+  /** CSS class added to a container when a grouped item hovers over it */
+  hoverClass?: string;
+  /**
+   * Group name — sortables with the same group can exchange items.
+   * Items can be dragged between any sortables sharing the same group name.
+   */
+  group?: string;
+  /** Called when order changes during drag (within same container) */
+  onSort?: (event: SortEvent) => void;
+  /** Called when drag ends and order is finalized */
+  onSortEnd?: (event: SortEvent) => void;
+  /** Called when an item is added from another sortable */
+  onAdd?: (event: SortTransferEvent) => void;
+  /** Called when an item is removed to another sortable */
+  onRemove?: (event: SortTransferEvent) => void;
+}
+interface SortEvent {
+  item: HTMLElement;
+  oldIndex: number;
+  newIndex: number;
+  items: HTMLElement[];
+}
+interface SortTransferEvent {
+  item: HTMLElement;
+  from: Sortable;
+  to: Sortable;
+  oldIndex: number;
+  newIndex: number;
+}
+declare class Sortable {
+  readonly container: HTMLElement;
+  private options;
+  private draggables;
+  private itemStates;
+  private dragItem;
+  private dragIndex;
+  private currentIndex;
+  private targetSortable;
+  private targetIndex;
+  private placeholder;
+  private _enabled;
+  private listeners;
+  on(event: string, handler: Function): this;
+  off(event: string, handler: Function): this;
+  private emit;
+  get enabled(): boolean;
+  set enabled(value: boolean);
+  constructor(container: HTMLElement, options?: SortableOptions);
+  getItems(): HTMLElement[];
+  private setup;
+  private handleDragStart;
+  private handleDragMove;
+  private updateWithinIndex;
+  private findTargetContainer;
+  private setTargetSortable;
+  private clearTargetSortable;
+  private updatePlaceholder;
+  private removePlaceholder;
+  private handleDragEnd;
+  snapshotItems(): void;
+  private animateItems;
+  private reorderDOM;
+  /** Refresh the sortable (e.g., after dynamically adding/removing items) */
+  refresh(): void;
+  /** Get the current order of items */
+  getOrder(): HTMLElement[];
+  /** Programmatically move an item */
+  move(fromIndex: number, toIndex: number): void;
+  private teardown;
+  destroy(): void;
+}
+declare function sortable(container: HTMLElement | string, options?: SortableOptions): Sortable;
+//#endregion
+//#region src/modifiers/restrict.d.ts
+interface RestrictOptions {
+  bounds?: 'parent' | HTMLElement | {
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+  };
+  elementRect?: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+  };
+  endOnly?: boolean;
+}
+declare class RestrictModifier implements Modifier {
+  name: string;
+  private options;
+  private transformBounds;
+  constructor(options: RestrictOptions);
+  onStart(context: ModifierContext): void;
+  modify(context: ModifierContext): ModifierResult;
+  onEnd(context: ModifierContext): ModifierResult;
+  private resolveAndCache;
+  private applyRestriction;
+  private resolveTransformBounds;
+}
+declare function restrict(options: RestrictOptions): RestrictModifier;
+//#endregion
+//#region src/modifiers/snap-grid.d.ts
+interface SnapGridOptions {
+  x: number;
+  y: number;
+  offset?: {
+    x: number;
+    y: number;
+  };
+  limits?: {
+    top?: number;
+    left?: number;
+    bottom?: number;
+    right?: number;
+  };
+}
+declare class SnapGridModifier implements Modifier {
+  name: string;
+  private options;
+  constructor(options: SnapGridOptions);
+  modify(context: ModifierContext): ModifierResult;
+}
+declare function snapGrid(options: SnapGridOptions): SnapGridModifier;
+//#endregion
+//#region src/modifiers/snap-targets.d.ts
+interface SnapTarget {
+  /** X coordinate of the target */
+  x?: number;
+  /** Y coordinate of the target */
+  y?: number;
+  /** Snap range in pixels (default: global range) */
+  range?: number;
+}
+/** Preset pivot positions */
+type PivotPreset = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
+interface SnapTargetsOptions {
+  /** Array of snap target positions */
+  targets: SnapTarget[];
+  /** Default snap range in pixels (default: 50) */
+  range?: number;
+  /**
+   * Pivot point(s) on the element to check for snapping.
+   * Accepts preset strings or {x,y} where 0-1 maps to element dimensions.
+   *
+   * Presets: 'top-left', 'top', 'top-right', 'left', 'center', 'right',
+   *          'bottom-left', 'bottom', 'bottom-right'
+   *
+   * Default: 'top-left'
+   */
+  relativePoints?: Array<PivotPreset | {
+    x: number;
+    y: number;
+  }>;
+  /**
+   * Coordinate mode:
+   * - 'offset' (default): targets are transform offsets
+   * - 'parent': targets are positions relative to the parent element's top-left
+   */
+  coordinateMode?: 'offset' | 'parent';
+}
+declare class SnapTargetsModifier implements Modifier {
+  name: string;
+  private options;
+  private parentOffset;
+  private _snappedTarget;
+  private _snappedIndex;
+  private resolvedPivots;
+  constructor(options: SnapTargetsOptions);
+  /** The target the element is currently snapped to, or null */
+  get snappedTarget(): SnapTarget | null;
+  /** The index of the snapped target in the targets array, or -1 */
+  get snappedIndex(): number;
+  /** Whether the element is currently snapped to any target */
+  get isSnapped(): boolean;
+  onStart(context: ModifierContext): void;
+  modify(context: ModifierContext): ModifierResult;
+}
+declare function snapTargets(options: SnapTargetsOptions): SnapTargetsModifier;
+//#endregion
+//#region src/modifiers/magnetic-snap.d.ts
+interface MagneticTarget {
+  id: string;
+  x: number;
+  y: number;
+  width?: number;
+  height?: number;
+  strength?: number;
+}
+interface MagneticSnapOptions {
+  targets: MagneticTarget[];
+  distance?: number;
+  strength?: number;
+  onSnap?: (target: MagneticTarget) => void;
+  onUnsnap?: (target: MagneticTarget) => void;
+}
+declare class MagneticSnapModifier implements Modifier {
+  name: string;
+  private options;
+  private currentTarget;
+  private targetMap;
+  constructor(options: MagneticSnapOptions);
+  updateTargets(targets: MagneticTarget[]): void;
+  addTarget(target: MagneticTarget): void;
+  removeTarget(id: string): void;
+  modify(context: ModifierContext): ModifierResult;
+  private getDistance;
+  getCurrentTarget(): MagneticTarget | null;
+  isSnapped(): boolean;
+}
+declare function magneticSnap(options: MagneticSnapOptions): MagneticSnapModifier;
+//#endregion
+//#region src/modifiers/inertia.d.ts
+interface InertiaOptions {
+  resistance?: number;
+  minSpeed?: number;
+  endSpeed?: number;
+  smoothEnd?: boolean;
+  smoothEndDuration?: number;
+}
+declare class InertiaModifier implements Modifier {
+  name: string;
+  private options;
+  private state;
+  constructor(options?: InertiaOptions);
+  onStart(): void;
+  modify(context: ModifierContext): ModifierResult;
+  onEnd(context: ModifierContext): ModifierResult | void;
+  private computeSmoothEnd;
+  isActive(): boolean;
+}
+declare function inertia(options?: InertiaOptions): InertiaModifier;
+//#endregion
+//#region src/modifiers/auto-scroll.d.ts
+interface AutoScrollOptions {
+  container?: HTMLElement | Window;
+  speed?: number;
+  margin?: number;
+  acceleration?: number;
+}
+declare class AutoScrollModifier implements Modifier {
+  name: string;
+  private options;
+  private animationFrame;
+  private cachedContainer;
+  private cachedContainerRect;
+  constructor(options?: AutoScrollOptions);
+  onStart(context: ModifierContext): void;
+  modify(context: ModifierContext): ModifierResult;
+  onEnd(): void;
+  private resolveContainer;
+  private getContainerRect;
+  private performScroll;
+}
+declare function autoScroll(options?: AutoScrollOptions): AutoScrollModifier;
+//#endregion
+//#region src/modifiers/rubberband.d.ts
+interface RubberbandOptions {
+  bounds: {
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+  } | 'parent';
+  /** Resistance factor 0-1 (default: 0.15). Lower = more resistance. */
+  resistance?: number;
+  /** Max overshoot in pixels (default: 100) */
+  maxOvershoot?: number;
+}
+declare class RubberbandModifier implements Modifier {
+  name: string;
+  private options;
+  private transformBounds;
+  constructor(options: RubberbandOptions);
+  onStart(context: ModifierContext): void;
+  modify(context: ModifierContext): ModifierResult;
+  onEnd(context: ModifierContext): ModifierResult;
+  private resolveTransformBounds;
+}
+declare function rubberband(options: RubberbandOptions): RubberbandModifier;
+//#endregion
+//#region src/modifiers/restrict-size.d.ts
+interface RestrictSizeOptions {
+  min?: {
+    width?: number;
+    height?: number;
+  };
+  max?: {
+    width?: number;
+    height?: number;
+  };
+}
+declare class RestrictSizeModifier implements Modifier {
+  name: string;
+  private options;
+  constructor(options: RestrictSizeOptions);
+  modify(context: ModifierContext): ModifierResult;
+}
+declare function restrictSize(options: RestrictSizeOptions): RestrictSizeModifier;
+//#endregion
+//#region src/modifiers/restrict-edges.d.ts
+interface RestrictEdgesOptions {
+  /** Restriction bounds for each edge — edges can't go beyond these values */
+  outer?: {
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+  };
+  /** Edges must stay within these values (can't pass toward center) */
+  inner?: {
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+  };
+}
+declare class RestrictEdgesModifier implements Modifier {
+  name: string;
+  private options;
+  constructor(options: RestrictEdgesOptions);
+  modify(context: ModifierContext): ModifierResult;
+}
+declare function restrictEdges(options: RestrictEdgesOptions): RestrictEdgesModifier;
+//#endregion
+//#region src/modifiers/snap-size.d.ts
+interface SnapSizeOptions {
+  width?: number;
+  height?: number;
+  offset?: {
+    width?: number;
+    height?: number;
+  };
+}
+declare class SnapSizeModifier implements Modifier {
+  name: string;
+  private options;
+  constructor(options: SnapSizeOptions);
+  modify(context: ModifierContext): ModifierResult;
+}
+declare function snapSize(options: SnapSizeOptions): SnapSizeModifier;
+//#endregion
+//#region src/modifiers/snap-edges.d.ts
+interface SnapEdgeTarget {
+  left?: number;
+  top?: number;
+  right?: number;
+  bottom?: number;
+  range?: number;
+}
+interface SnapEdgesOptions {
+  targets: SnapEdgeTarget[];
+  range?: number;
+}
+declare class SnapEdgesModifier implements Modifier {
+  name: string;
+  private options;
+  constructor(options: SnapEdgesOptions);
+  modify(context: ModifierContext): ModifierResult;
+}
+declare function snapEdges(options: SnapEdgesOptions): SnapEdgesModifier;
+//#endregion
+//#region src/aria.d.ts
+interface AriaMessages {
+  instructions: string;
+  pickedUp: (label: string, position: number, total: number) => string;
+  movedTo: (position: number, total: number) => string;
+  dropped: (label: string, position: number, total: number) => string;
+  dragPickedUp: string;
+  dragDropped: string;
+}
+/** Override announcement messages for i18n / localization */
+declare function setMessages(custom: Partial<AriaMessages>): void;
+/** Get current messages (for reading) */
+declare function getMessages(): Readonly<AriaMessages>;
+declare function announce(message: string): void;
+//#endregion
+//#region src/index.d.ts
+interface InteractableOptions {
+  drag?: boolean | DragOptions;
+  resize?: boolean | ResizeOptions;
+  gesture?: boolean | GestureOptions;
+}
+declare function interactable(element: HTMLElement | string, options?: InteractableOptions): {
+  drag: Draggable | null;
+  resize: Resizable | null;
+  gesture: Gesturable | null;
+  destroy(): void;
+};
+declare function interactAll(selector: string, options?: InteractableOptions): {
+  instances: {
+    drag: Draggable | null;
+    resize: Resizable | null;
+    gesture: Gesturable | null;
+    destroy(): void;
+  }[];
+  destroy(): void;
+};
+//#endregion
+export { type ActiveEdges, type AriaMessages, type DragEvent, type DragOptions, Draggable, type DropEvent, Dropzone, DropzoneManager, type DropzoneOptions, Gesturable, type GestureEvent, type GestureOptions, Grip, type GripOptions, InteractableOptions, type InteractionEvent, type Modifier, type ModifierContext, type ModifierResult, type Point, type PointerState, type Rect, Resizable, type ResizeEvent, type ResizeOptions, type SortEvent, type SortTransferEvent, Sortable, type SortableOptions, announce, applyModifiers, autoScroll, interactable as default, interactable, draggable, dropzone, gesturable, getMessages, grip, inertia, interactAll, magneticSnap, resizable, restrict, restrictEdges, restrictSize, rubberband, setMessages, snapEdges, snapGrid, snapSize, snapTargets, sortable };
+//# sourceMappingURL=pointrix.d.cts.map