@kritzel/engine 0.4.31

package/dist/types/interfaces/asset-storage-config.interface.d.ts

@@ -0,0 +1,40 @@
+import { AssetProviderConfig } from './asset-provider.interface';
+/**
+ * Configuration for the asset storage layer used by Kritzel to store
+ * binary payloads (images, etc.) outside of the Yjs CRDT.
+ *
+ * The Yjs document only stores asset ids; the actual bytes live in the
+ * providers configured here. This keeps CRDT updates tiny regardless of
+ * attachment size.
+ *
+ * @example Local-only (offline friendly):
+ * ```ts
+ * { providers: [IndexedDBAssetProvider] }
+ * ```
+ *
+ * @example Write-through to a REST backend with IDB cache:
+ * ```ts
+ * {
+ *   providers: [
+ *     IndexedDBAssetProvider,
+ *     HttpAssetProvider.with({
+ *       uploadUrl: () => '/api/assets',
+ *       resolveUrl: (id) => `/api/assets/${id}`,
+ *       headers: async () => ({ Authorization: `Bearer ${await getToken()}` }),
+ *     }),
+ *   ],
+ * }
+ * ```
+ */
+export interface KritzelAssetStorageConfig {
+    /**
+     * Ordered list of asset providers. Resolution walks the list in order
+     * and returns the first provider that can serve a given id (typically
+     * the local cache first, then the remote authority).
+     *
+     * For uploads, the resolver writes to every provider in a write-through
+     * fashion: local providers receive the bytes immediately; remote
+     * providers are written via a persistent background queue.
+     */
+    providers: AssetProviderConfig[];
+}

package/dist/types/interfaces/asset.interface.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Kinds of assets that can be stored via an asset storage provider.
+ * Images are the primary consumer today; other kinds are reserved so a
+ * single provider infrastructure can serve future object types.
+ */
+export type KritzelAssetKind = 'image' | 'video' | 'audio' | 'file';
+/**
+ * Describes a stored binary asset.
+ * Only the `id` is persisted inside the Yjs document on Kritzel objects;
+ * all other fields are metadata carried by the asset layer.
+ */
+export interface KritzelAsset {
+    /** Stable identifier (uuid). Persisted inside canvas objects. */
+    id: string;
+    /** Coarse kind used to dispatch consumers. */
+    kind: KritzelAssetKind;
+    /** MIME type of the stored bytes (e.g. `image/png`). */
+    mimeType: string;
+    /** Size of the stored bytes in bytes. */
+    size: number;
+    /** Creation timestamp (ms since epoch). */
+    createdAt: number;
+    /** Optional width hint (pixels) for visual assets. */
+    width?: number;
+    /** Optional height hint (pixels) for visual assets. */
+    height?: number;
+    /** Optional duration hint (milliseconds) for time-based assets. */
+    durationMs?: number;
+    /** Optional original filename as supplied by the user. */
+    originalFilename?: string;
+    /**
+     * Names of remote providers that have not yet successfully received a
+     * copy of this asset. When non-empty, the resolver will keep retrying
+     * the upload in the background. Empty / undefined means the asset is
+     * fully replicated (or no remote providers are configured).
+     */
+    pendingRemotes?: string[];
+}
+/**
+ * Lifecycle state used by consumers (e.g. the renderer) to react to
+ * in-flight asset resolution without having to poll.
+ */
+export type KritzelAssetLoadState = 'idle' | 'loading' | 'ready' | 'error';

package/dist/types/interfaces/bounding-box.interface.d.ts

@@ -0,0 +1,8 @@
+export interface KritzelBoundingBox {
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    depth?: number;
+}

package/dist/types/interfaces/clonable.interface.d.ts

@@ -0,0 +1,3 @@
+export interface KritzelClonable<T> {
+    clone(): T;
+}

package/dist/types/interfaces/context-menu-item.interface.d.ts

@@ -0,0 +1,25 @@
+import { KritzelBaseObject } from "../classes/objects/base-object.class";
+import { KritzelTermKey } from "./localization.interface";
+export interface ContextMenuItem {
+    /**
+     * The item label. Always resolved through the active locale: pass a
+     * {@link KritzelTermKey} (e.g. `'menu.copy'`) to display its translation, or
+     * any other string to use it verbatim. Known term keys are autocompleted.
+     */
+    label: KritzelTermKey | (string & NonNullable<unknown>);
+    action?: (menu: {
+        x: number;
+        y: number;
+    }, objects: KritzelBaseObject[]) => void;
+    icon?: string;
+    group?: string;
+    children?: ContextMenuItem[];
+    isVisible?: boolean | ((menu: {
+        x: number;
+        y: number;
+    }, objects: KritzelBaseObject[]) => boolean | Promise<boolean>);
+    isDisabled?: boolean | ((menu: {
+        x: number;
+        y: number;
+    }, objects: KritzelBaseObject[]) => boolean | Promise<boolean>);
+}

package/dist/types/interfaces/context-menu-state.interface.d.ts

@@ -0,0 +1,16 @@
+import { KritzelBaseObject } from '../classes/objects/base-object.class';
+import { ContextMenuItem } from './context-menu-item.interface';
+export interface KritzelContextMenuState {
+    isVisible: boolean;
+    isObjectMenu: boolean;
+    items: ContextMenuItem[];
+    objects: KritzelBaseObject[];
+    position: {
+        x: number;
+        y: number;
+    };
+    worldPosition: {
+        x: number;
+        y: number;
+    };
+}

package/dist/types/interfaces/debug-info.interface.d.ts

@@ -0,0 +1,7 @@
+export interface KritzelDebugInfo {
+    showViewportInfo: boolean;
+    showObjectInfo: boolean;
+    showSyncProviderInfo: boolean;
+    showMigrationInfo: boolean;
+    showAssetResolverInfo: boolean;
+}

package/dist/types/interfaces/dialog.interface.d.ts

@@ -0,0 +1,4 @@
+export type KritzelDialogCloseReason = 'backdrop' | 'escape' | 'close-button' | 'programmatic';
+export interface IKritzelDialogCloseEvent {
+    reason: KritzelDialogCloseReason;
+}

package/dist/types/interfaces/document-metadata.interface.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type of a Y.Doc managed by Kritzel.
+ * - 'workspace': Contains drawable objects for a specific workspace
+ * - 'state': Contains application-level state (workspace list, settings)
+ */
+export type KritzelDocumentType = 'workspace' | 'state';

package/dist/types/interfaces/dynamic-object-renderer.interface.d.ts

@@ -0,0 +1,40 @@
+import { KritzelDynamicObject } from '../classes/objects/dynamic-object.class';
+/**
+ * Context passed to a renderer when mounting, updating, or unmounting.
+ */
+export interface KritzelDynamicObjectRenderContext {
+    /** The dynamic object object being rendered. */
+    object: KritzelDynamicObject;
+    /** Container element to render into (mount) or receive lifecycle notifications (unmount). */
+    container: HTMLElement | null;
+    /** Custom data payload for the renderer (e.g., component props, state). */
+    data?: unknown;
+}
+/**
+ * Renderer implementation for dynamic objects on the canvas.
+ * Handles framework-specific mounting, updating, and cleanup.
+ */
+export interface KritzelDynamicObjectRenderer {
+    /**
+     * Called when the dynamic object enters the viewport or is first added to canvas.
+     * Renderer is responsible for creating and appending DOM to context.container.
+     * @param context - Render context with object, container, and data
+     */
+    onMount(context: KritzelDynamicObjectRenderContext): void;
+    /**
+     * Called when object properties (position, size, rotation, etc.) change.
+     * Renderer can react to dimension/transform updates or data changes.
+     * Optional; default is no-op.
+     * @param context - Render context with updated object and data
+     * @param changedProperties - Array of property names that changed
+     */
+    onUpdate?(context: KritzelDynamicObjectRenderContext, changedProperties: string[]): void;
+    /**
+     * Called when the object leaves the viewport, is deleted, or workspace is unloaded.
+     * Renderer must clean up event listeners, timers, framework instances, and remove DOM.
+     * May optionally return updated data to capture back into object.rendererData.
+     * @param context - Render context with object and container
+     * @returns Optional updated data payload to persist
+     */
+    onUnmount(context: KritzelDynamicObjectRenderContext): unknown;
+}

package/dist/types/interfaces/engine-state.interface.d.ts

@@ -0,0 +1,82 @@
+import { KritzelBaseObject } from "../classes/objects/base-object.class";
+import { KritzelObjectMap } from "../classes/structures/object-map.structure";
+import { KritzelBaseTool } from "../classes/tools/base-tool.class";
+import { KritzelWorkspace } from "../classes/core/workspace.class";
+import { KritzelHandleType } from "../enums/handle-type.enum";
+import { ContextMenuItem } from "./context-menu-item.interface";
+import { KritzelDebugInfo } from "./debug-info.interface";
+import { LineHandleType } from "../classes/handlers/line-handle.handler";
+import { SnapCandidate, SnapPreviewCandidate } from "./anchor.interface";
+export interface KritzelEngineState {
+    activeWorkspace: KritzelWorkspace | null | undefined;
+    activeTool: KritzelBaseTool | null;
+    objects: KritzelObjectMap<KritzelBaseObject<Element>> | null;
+    snapCandidate?: SnapCandidate | null;
+    snapPreviewCandidate?: SnapPreviewCandidate | null;
+    resizeHandleType: KritzelHandleType | undefined;
+    lineHandleType: LineHandleType | undefined;
+    hasViewportChanged: boolean;
+    hasObjectsChanged: boolean;
+    isReady: boolean;
+    isEnabled: boolean;
+    isScaling: boolean;
+    isPanning: boolean;
+    isSelecting: boolean;
+    isResizing: boolean;
+    isResizeHandleHovered: boolean;
+    isResizeHandleSelected: boolean;
+    isRotating: boolean;
+    isRotationHandleHovered: boolean;
+    isRotationHandleSelected: boolean;
+    isLineHandleSelected: boolean;
+    isLineHandleDragging: boolean;
+    isDragging: boolean;
+    isDrawing: boolean;
+    isErasing: boolean;
+    isWriting: boolean;
+    isLoading: boolean;
+    isCtrlKeyPressed: boolean;
+    isContextMenuVisible: boolean;
+    contextMenuItems: ContextMenuItem[];
+    contextMenuX: number;
+    contextMenuY: number;
+    contextMenuWorldX: number;
+    contextMenuWorldY: number;
+    skipContextMenu: boolean;
+    debugInfo: KritzelDebugInfo;
+    host: HTMLElement | null;
+    pointerX: number;
+    pointerY: number;
+    scale: number;
+    scaleMax: number;
+    scaleMin: number;
+    startX: number;
+    startY: number;
+    translateX: number;
+    translateXMax: number;
+    translateXMin: number;
+    translateY: number;
+    translateYMax: number;
+    translateYMin: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    longTouchTimeout: number | null;
+    longTouchDelay: number;
+    pointers: Map<number, PointerEvent>;
+    workspaces: KritzelWorkspace[];
+    cursor: {
+        icon: string;
+        iconActive?: string;
+        rotation?: number;
+    };
+    /** When true, objects are drawn at a fixed visual size regardless of zoom level */
+    lockDrawingScale: boolean;
+    /** Left boundary of the viewport in world coordinates */
+    viewportBoundaryLeft: number;
+    /** Right boundary of the viewport in world coordinates */
+    viewportBoundaryRight: number;
+    /** Top boundary of the viewport in world coordinates */
+    viewportBoundaryTop: number;
+    /** Bottom boundary of the viewport in world coordinates */
+    viewportBoundaryBottom: number;
+}

package/dist/types/interfaces/font.interface.d.ts

@@ -0,0 +1,15 @@
+export interface KritzelFontDefinition {
+    family: string;
+    label?: string;
+    cssFontFamily?: string;
+    source?: string;
+}
+export type KritzelFontRegistration = string | KritzelFontDefinition;
+export interface KritzelRegisteredFont {
+    key: string;
+    family: string;
+    label: string;
+    cssFontFamily: string;
+    source?: string;
+}
+export type KritzelFontMap = Record<string, KritzelFontRegistration>;

package/dist/types/interfaces/localization.interface.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Canonical locale identifier type for available locales.
+ * Locales are identified by their code (e.g. 'en', 'de', 'fr').
+ * The union is open so consumers can register additional locale codes.
+ */
+export type LocaleCode = 'en' | 'de' | 'fr' | (string & NonNullable<unknown>);
+/**
+ * Typed map of all known user-visible UI term keys to their translated strings.
+ *
+ * Keys are namespaced with a dotted prefix (e.g. `menu.copy`, `settings.title`)
+ * to group related strings. Using a closed interface gives full compile-time
+ * safety: typos in term keys are caught by the compiler and editors can
+ * autocomplete the available keys.
+ */
+export interface KritzelTerms {
+    'menu.copy': string;
+    'menu.cut': string;
+    'menu.paste': string;
+    'menu.selectAll': string;
+    'menu.order': string;
+    'menu.bringToFront': string;
+    'menu.sendToBack': string;
+    'menu.moveUp': string;
+    'menu.moveDown': string;
+    'menu.align': string;
+    'menu.alignLeft': string;
+    'menu.alignCenterHorizontal': string;
+    'menu.alignRight': string;
+    'menu.alignTop': string;
+    'menu.alignCenterVertical': string;
+    'menu.alignBottom': string;
+    'menu.group': string;
+    'menu.ungroup': string;
+    'menu.export': string;
+    'menu.exportAsSvg': string;
+    'menu.exportAsPng': string;
+    'menu.delete': string;
+    'menu.share': string;
+    'menu.import': string;
+    'menu.settings': string;
+    'menu.logout': string;
+    'settings.dialogTitle': string;
+    'settings.categories.general': string;
+    'settings.categories.viewport': string;
+    'settings.categories.shortcuts': string;
+    'settings.categories.developer': string;
+    'settings.categories.about': string;
+    'settings.general.title': string;
+    'settings.general.theme.label': string;
+    'settings.general.theme.description': string;
+    'settings.general.language.label': string;
+    'settings.general.language.description': string;
+    'settings.general.lockDrawingScale.label': string;
+    'settings.general.lockDrawingScale.description': string;
+    'settings.viewport.title': string;
+    'settings.viewport.minZoom.label': string;
+    'settings.viewport.minZoom.description': string;
+    'settings.viewport.maxZoom.label': string;
+    'settings.viewport.maxZoom.description': string;
+    'settings.viewport.boundaryLeft.label': string;
+    'settings.viewport.boundaryLeft.description': string;
+    'settings.viewport.boundaryRight.label': string;
+    'settings.viewport.boundaryRight.description': string;
+    'settings.viewport.boundaryTop.label': string;
+    'settings.viewport.boundaryTop.description': string;
+    'settings.viewport.boundaryBottom.label': string;
+    'settings.viewport.boundaryBottom.description': string;
+    'settings.viewport.boundaryPlaceholder': string;
+    'settings.shortcuts.title': string;
+    'settings.developer.title': string;
+    'settings.developer.showViewportInfo.label': string;
+    'settings.developer.showViewportInfo.description': string;
+    'settings.developer.showObjectInfo.label': string;
+    'settings.developer.showObjectInfo.description': string;
+    'settings.developer.showSyncProviderInfo.label': string;
+    'settings.developer.showSyncProviderInfo.description': string;
+    'settings.developer.showMigrationInfo.label': string;
+    'settings.developer.showMigrationInfo.description': string;
+    'settings.about.title': string;
+    'settings.about.description': string;
+    'export.dialogTitle': string;
+    'export.tabs.viewport': string;
+    'export.tabs.workspace': string;
+    'export.format.label': string;
+    'export.filename.label': string;
+    'export.filename.placeholder': string;
+    'export.exportButton': string;
+    'workspace.sharedTooltip': string;
+    'workspace.rename': string;
+    'workspace.delete': string;
+    'zoom.zoomIn': string;
+    'zoom.zoomOut': string;
+    'utility.undo': string;
+    'utility.redo': string;
+    'utility.delete': string;
+    'share.dialogTitle': string;
+    'share.linkSharing.label': string;
+    'share.linkSharing.enabledDescription': string;
+    'share.linkSharing.disabledDescription': string;
+    'share.linkSharing.toggleLabel': string;
+    'share.copyLink.title': string;
+    'share.copyLink.copied': string;
+    'login.dialogTitle': string;
+    'currentUser.dialogTitle': string;
+    'backToContent.label': string;
+    'toolConfig.collapse': string;
+    'toolConfig.expand': string;
+    'moreMenu.ariaLabel': string;
+    'editor.loading': string;
+    'watermark.poweredBy': string;
+}
+/**
+ * A localization key. Restricted to the known {@link KritzelTerms} keys so that
+ * lookups are validated at compile time.
+ */
+export type KritzelTermKey = keyof KritzelTerms;
+/**
+ * Definition of a single locale.
+ *
+ * `terms` is a `Partial<KritzelTerms>`, so a locale may override only a subset
+ * of the available terms. Any missing term is resolved through the fallback
+ * chain (see {@link KritzelLocalizationManager}). This mirrors the theming API,
+ * allowing consumers to spread a built-in locale and override specific keys:
+ *
+ * ```ts
+ * const myDe: KritzelLocale = {
+ *   code: 'de',
+ *   terms: { ...DE_LOCALE.terms, 'menu.copy': 'Duplizieren' },
+ * };
+ * ```
+ */
+export interface KritzelLocale {
+    /** Canonical locale code, e.g. 'en', 'de', 'fr'. */
+    code: LocaleCode;
+    /** Optional human-readable display name shown in the language selector, e.g. 'Deutsch'. */
+    label?: string;
+    /** Partial map of term keys to translated strings. Missing keys fall back. */
+    terms: Partial<KritzelTerms>;
+}
+/**
+ * Values used to interpolate `{placeholder}` tokens inside a translated term.
+ */
+export type KritzelTermVars = Record<string, string | number>;

package/dist/types/interfaces/login-config.interface.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents an authentication provider button displayed in the login dialog.
+ */
+export interface KritzelLoginProvider {
+    /** Machine identifier emitted in events (e.g. 'google', 'apple', 'facebook') */
+    name: string;
+    /** Button label text (e.g. 'Continue with Google') */
+    label: string;
+    /** Optional icon name registered in KritzelIconRegistry via customSvgIcons */
+    icon?: string;
+}
+/**
+ * Configuration for the integrated login dialog.
+ * When provided to kritzel-editor, a "Sign in" button is rendered that opens
+ * a dialog with the configured authentication provider buttons.
+ */
+export interface KritzelLoginConfig {
+    /** Array of authentication provider buttons to render */
+    providers: KritzelLoginProvider[];
+    /** Dialog title (defaults to 'Sign in') */
+    title?: string;
+    /** Optional subtitle text displayed below the title */
+    subtitle?: string;
+}

package/dist/types/interfaces/master-detail.interface.d.ts

@@ -0,0 +1,14 @@
+export interface IKritzelMasterDetailItem {
+    /** Unique identifier for the item */
+    id: string;
+    /** Display label for the menu item */
+    label: string;
+    /** Optional icon name (for kritzel-icon) */
+    icon?: string;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+}
+export interface IKritzelMasterDetailSelectEvent {
+    /** The selected item */
+    item: IKritzelMasterDetailItem;
+}

package/dist/types/interfaces/menu-item.interface.d.ts

@@ -0,0 +1,27 @@
+export interface IKritzelMenuItem<T = any> {
+    id: string;
+    label: string;
+    icon?: string;
+    iconTooltip?: string;
+    color?: string;
+    value?: T;
+    children?: IKritzelMenuItem[];
+    isSelectable?: boolean;
+    isSelected?: boolean;
+    isEditing?: boolean;
+    isDisabled?: boolean;
+    isVisible?: boolean | (() => boolean | Promise<boolean>);
+    isChildMenuOpen?: boolean;
+    isNewItem?: boolean;
+    childMenuAnchor?: HTMLElement;
+    unchangedState?: Partial<IKritzelMenuItem>;
+    action?: (item: IKritzelMenuItem, parent: IKritzelMenuItem) => void;
+}
+export interface IKritzelMenuItemSelectEvent {
+    item: IKritzelMenuItem;
+    parent: IKritzelMenuItem;
+}
+export interface IKritzelMenuItemToggleChildMenuEvent {
+    item: IKritzelMenuItem;
+    childMenuAnchor: HTMLElement;
+}

package/dist/types/interfaces/migration.interface.d.ts

@@ -0,0 +1,16 @@
+import * as Y from 'yjs';
+/**
+ * Describes a single schema migration step for a Y.Doc.
+ * Migrations transform the data stored in Yjs maps from one schema version to another.
+ *
+ * Each migration must be idempotent — in a collaborative environment, multiple clients
+ * may execute the same migration concurrently due to Yjs CRDT merging.
+ */
+export interface KritzelMigration {
+    /** The schema version this migration upgrades from. */
+    fromVersion: number;
+    /** The schema version this migration upgrades to. Must equal fromVersion + 1. */
+    toVersion: number;
+    /** Mutates the Yjs maps in-place to transform data from fromVersion to toVersion. */
+    migrate(ydoc: Y.Doc, maps: Record<string, Y.Map<any>>): void;
+}

package/dist/types/interfaces/notification.interface.d.ts

@@ -0,0 +1,10 @@
+export interface KritzelNotification {
+    /** Unique identifier for the notification */
+    id: string;
+    /** Type of the notification (e.g., 'info', 'warning', 'error') */
+    type: 'info' | 'warning' | 'error';
+    /** Message content of the notification */
+    message: string;
+    /** Optional timestamp for when the notification was created */
+    timestamp?: Date;
+}

package/dist/types/interfaces/object-change-event.interface.d.ts

@@ -0,0 +1,31 @@
+import { KritzelBaseObject } from '../classes/objects/base-object.class';
+/**
+ * Emitted when one or more objects are added to the canvas.
+ */
+export interface ObjectsAddedEvent {
+    objects: KritzelBaseObject[];
+}
+/**
+ * Emitted when one or more objects are removed from the canvas.
+ * Contains snapshots of the objects before removal.
+ */
+export interface ObjectsRemovedEvent {
+    objects: KritzelBaseObject[];
+}
+/**
+ * Emitted when one or more objects are updated on the canvas.
+ * Each entry contains the updated object and the list of changed property keys.
+ */
+export interface ObjectsUpdatedEvent {
+    objects: {
+        object: KritzelBaseObject;
+        changedProperties: string[];
+    }[];
+}
+/**
+ * Payload emitted when the set of objects visible in the current viewport changes
+ * (e.g., after a pan or zoom).
+ * Kept as a named alias so wrapper proxy generators don't try to import
+ * the DOM global `Element` from `@kritzel/engine` (which causes TS2749).
+ */
+export type ObjectsInViewportChangeEvent = KritzelBaseObject<Element>[];

package/dist/types/interfaces/object-export.interface.d.ts

@@ -0,0 +1,20 @@
+import { KritzelBaseObject } from '../classes/objects/base-object.class';
+export type KritzelObjectExportFormat = 'png' | 'svg';
+/**
+ * Runtime context passed to object-owned export methods.
+ * The engine provides these callbacks so object classes can request
+ * serialization/rasterization without owning global dependencies.
+ */
+export interface KritzelObjectExportContext {
+    getObjectAsSvgDataUrl(object: KritzelBaseObject, options?: {
+        rasterSafeForCanvas?: boolean;
+    }): Promise<string | null>;
+    getObjectAsPngDataUrl(object: KritzelBaseObject): Promise<string | null>;
+}
+/**
+ * Capability contract for objects that can export themselves.
+ */
+export interface KritzelExportable {
+    getSupportedExportFormats(): KritzelObjectExportFormat[];
+    exportAs(format: KritzelObjectExportFormat, context: KritzelObjectExportContext): Promise<string | null>;
+}

package/dist/types/interfaces/object.interface.d.ts

@@ -0,0 +1,53 @@
+import { KritzelBaseObject } from '../classes/objects/base-object.class';
+import { KritzelBoundingBox } from './bounding-box.interface';
+import { KritzelPolygon } from './polygon.interface';
+import { ThemeAwareColor } from '../constants/color-palette.constants';
+export interface KritzelObject<T = Element> {
+    _elementRef: T;
+    id: string;
+    workspaceId: string;
+    x: number;
+    y: number;
+    translateX: number;
+    translateY: number;
+    height: number;
+    width: number;
+    backgroundColor?: ThemeAwareColor;
+    borderColor?: ThemeAwareColor;
+    borderWidth: number;
+    opacity: number;
+    scale?: number;
+    resizing: boolean;
+    rotation: number;
+    markedForRemoval: boolean;
+    zIndex: number;
+    userId?: string;
+    isVisible: boolean;
+    isSelected: boolean;
+    isHovered: boolean;
+    isMounted: boolean;
+    isEditable: boolean;
+    isInteractive: boolean;
+    set elementRef(element: T);
+    get elementRef(): T;
+    get boundingBox(): KritzelBoundingBox;
+    get totalWidth(): number;
+    get totalHeight(): number;
+    get rotationDegrees(): number;
+    get centerX(): number;
+    get centerY(): number;
+    mount(element: T): void;
+    generateId(): string;
+    isInViewport(viewport: KritzelBoundingBox, scale: number): boolean;
+    centerInViewport(): void;
+    update(): void;
+    move(startX: number, startY: number, endX: number, endY: number): void;
+    resize(x: number, y: number, width: number, height: number): void;
+    rotate(value: number): void;
+    copy(): KritzelBaseObject<Element>;
+    isClass<T extends KritzelBaseObject>(this: T, type: string): this is T;
+    edit(event?: PointerEvent): void;
+    hitTest(x: number, y: number): boolean;
+    hitTestPolygon(polygon: KritzelPolygon): boolean;
+    updatePosition(x: number, y: number): void;
+}

package/dist/types/interfaces/paste-intent-provider.interface.d.ts

@@ -0,0 +1,10 @@
+import { KritzelCore } from '../classes/core/core.class';
+import { PasteIntent } from '../classes/managers/clipboard.types';
+export interface KritzelPasteIntentProviderContext {
+    core: KritzelCore;
+    event?: ClipboardEvent;
+}
+export interface KritzelPasteIntentProvider {
+    canHandle(context: KritzelPasteIntentProviderContext): boolean;
+    getPasteIntent(context: KritzelPasteIntentProviderContext): Promise<PasteIntent>;
+}