@kritzel/engine 0.4.31

package/dist/types/classes/providers/assets/http-asset-provider.class.d.ts

@@ -0,0 +1,79 @@
+import { KritzelAsset } from '../../../interfaces/asset.interface';
+import { IAssetStorageProvider, KritzelAssetPutMetadata } from '../../../interfaces/asset-provider.interface';
+/**
+ * Response shape expected from the upload endpoint. Fields are optional
+ * so that different server designs can be accommodated; if `id` is not
+ * returned, the pre-generated id passed via metadata is used.
+ */
+export interface HttpAssetUploadResponse {
+    id?: string;
+    url?: string;
+}
+/**
+ * Options for {@link HttpAssetProvider}.
+ *
+ * The host application owns authentication. Any credentials or tokens
+ * should be injected via the `headers` callback so the library never
+ * holds long-lived secrets.
+ */
+export interface HttpAssetProviderOptions {
+    /**
+     * Returns the URL the asset should be POSTed to.
+     * Called once per upload; may be async to support signed endpoints.
+     */
+    uploadUrl: (metadata: KritzelAssetPutMetadata) => string | Promise<string>;
+    /**
+     * Returns the URL from which a given asset id can be loaded.
+     * This URL is used directly as the `<img src>`.
+     */
+    resolveUrl: (id: string) => string | Promise<string>;
+    /**
+     * Optional custom headers (auth tokens, tenant ids, ...) attached to
+     * every request. Called per request so tokens can be refreshed.
+     */
+    headers?: () => Record<string, string> | Promise<Record<string, string>>;
+    /**
+     * Quiet mode - suppress console output (optional, defaults to false)
+     */
+    quiet?: boolean;
+    /**
+     * Upload transport. Defaults to a single `POST` carrying a
+     * `multipart/form-data` body with the file and metadata as JSON.
+     * Override when the backend expects a different shape.
+     */
+    upload?: (url: string, blob: Blob, metadata: KritzelAssetPutMetadata, headers: Record<string, string>) => Promise<HttpAssetUploadResponse>;
+    /**
+     * Optional override for DELETE requests. Omit to disable deletion.
+     */
+    deleteUrl?: (id: string) => string | Promise<string>;
+}
+/**
+ * Remote asset storage provider backed by a plain HTTP endpoint.
+ *
+ * The host application is responsible for exposing a REST-ish backend
+ * that accepts a multipart upload and serves the stored asset at a
+ * stable URL. Authentication is injected via `headers`.
+ */
+export declare class HttpAssetProvider implements IAssetStorageProvider {
+    readonly type = "remote";
+    readonly name = "HttpAssetProvider";
+    private _options;
+    constructor(options: HttpAssetProviderOptions);
+    /**
+     * Factory helper enabling use as `HttpAssetProvider.with({ ... })` inside
+     * a `KritzelAssetStorageConfig.providers` array.
+     */
+    static with(options: HttpAssetProviderOptions): {
+        create: () => IAssetStorageProvider;
+    };
+    init(): Promise<void>;
+    destroy(): void;
+    canResolve(_id: string): boolean;
+    put(blob: Blob, metadata: KritzelAssetPutMetadata): Promise<KritzelAsset>;
+    resolve(id: string): Promise<string>;
+    fetch(id: string): Promise<Blob>;
+    delete(id: string): Promise<void>;
+    private defaultUpload;
+    private extensionFromMime;
+    private generateUuid;
+}

package/dist/types/classes/providers/assets/indexeddb-asset-provider.class.d.ts

@@ -0,0 +1,69 @@
+import { KritzelAsset } from '../../../interfaces/asset.interface';
+import { IAssetStorageProvider, KritzelAssetPutMetadata } from '../../../interfaces/asset-provider.interface';
+/**
+ * Options for {@link IndexedDBAssetProvider}.
+ */
+export interface IndexedDBAssetProviderOptions {
+    /** Custom database name. Defaults to `kritzel-assets`. */
+    dbName?: string;
+    /**
+     * Quiet mode - suppress console output (optional, defaults to false)
+     */
+    quiet?: boolean;
+}
+/**
+ * Local-only asset storage provider backed by IndexedDB.
+ *
+ * Stores asset blobs and metadata in a dedicated database (separate from
+ * the Yjs IndexedDB sync provider). Resolved URLs are `blob:` object URLs
+ * created on demand and cached to avoid redundant allocations.
+ *
+ * This provider is always-safe to include in an asset storage config; it
+ * doubles as an offline cache when combined with a remote provider.
+ */
+export declare class IndexedDBAssetProvider implements IAssetStorageProvider {
+    readonly type = "local";
+    readonly name = "IndexedDBAssetProvider";
+    private _dbName;
+    private _db;
+    /** In-memory cache of id -> object URL to avoid re-creating blob URLs. */
+    private _urlCache;
+    /** In-memory known-present ids to let `canResolve` answer synchronously. */
+    private _knownIds;
+    constructor(options?: IndexedDBAssetProviderOptions);
+    /**
+     * Factory helper enabling use as `IndexedDBAssetProvider.with({ dbName: '...' })`
+     * inside a `KritzelAssetStorageConfig.providers` array.
+     */
+    static with(options: IndexedDBAssetProviderOptions): {
+        create: () => IAssetStorageProvider;
+    };
+    init(): Promise<void>;
+    destroy(): void;
+    canResolve(id: string): boolean;
+    put(blob: Blob, metadata: KritzelAssetPutMetadata): Promise<KritzelAsset>;
+    resolve(id: string): Promise<string>;
+    fetch(id: string): Promise<Blob>;
+    delete(id: string): Promise<void>;
+    /**
+     * Returns the metadata record for a stored asset, or `undefined` when
+     * the asset is not present locally.
+     */
+    getMetadata(id: string): Promise<KritzelAsset | undefined>;
+    /**
+     * Returns every stored asset that still has one or more remote
+     * providers marked as pending. Used by the resolver on init to
+     * re-enqueue uploads that were interrupted (e.g. the user reloaded
+     * the tab while a background upload was retrying).
+     */
+    listAssetsWithPendingRemotes(): Promise<KritzelAsset[]>;
+    /**
+     * Replaces the `pendingRemotes` list on an asset's metadata record.
+     * Passing an empty array clears the pending flag entirely.
+     */
+    setPendingRemotes(id: string, providerNames: string[]): Promise<void>;
+    private ensureDb;
+    private openDatabase;
+    private loadKnownIds;
+    private generateUuid;
+}

package/dist/types/classes/providers/assets/presigned-asset-provider.class.d.ts

@@ -0,0 +1,69 @@
+import { KritzelAsset } from '../../../interfaces/asset.interface';
+import { IAssetStorageProvider, KritzelAssetPutMetadata } from '../../../interfaces/asset-provider.interface';
+/**
+ * Pre-signed upload descriptor returned by the host application.
+ * `method` defaults to `PUT` which matches the common S3 pattern, but
+ * `POST` is also supported for S3 browser-based uploads with form fields.
+ */
+export interface KritzelPresignedUpload {
+    /** Stable asset id. Host may honor metadata.id or assign a new one. */
+    id: string;
+    /** Fully-qualified URL bytes should be sent to. */
+    url: string;
+    /** HTTP method. Defaults to `PUT`. */
+    method?: 'PUT' | 'POST';
+    /** Extra form fields (S3 browser-based uploads). Only used for POST. */
+    fields?: Record<string, string>;
+    /** Extra request headers (e.g. `Content-Type`, `x-amz-*`). */
+    headers?: Record<string, string>;
+}
+/**
+ * Options for {@link PresignedAssetProvider}.
+ *
+ * This provider delegates upload URL signing and download URL signing to
+ * the host application. The library never sees storage credentials.
+ */
+export interface PresignedAssetProviderOptions {
+    /**
+     * Returns a pre-signed upload descriptor for the given metadata. The
+     * host application typically calls its backend to obtain a signed URL.
+     */
+    getUploadDescriptor: (metadata: KritzelAssetPutMetadata) => Promise<KritzelPresignedUpload>;
+    /**
+     * Returns a URL from which the given asset can be loaded (often a
+     * short-lived signed GET URL).
+     */
+    getDownloadUrl: (id: string) => Promise<string>;
+    /**
+     * Optional delete hook. Called with the asset id; host signs and
+     * dispatches a DELETE to the underlying storage. Omit to disable.
+     */
+    deleteAsset?: (id: string) => Promise<void>;
+    /**
+     * Quiet mode - suppress console output (optional, defaults to false)
+     */
+    quiet?: boolean;
+}
+/**
+ * Remote asset storage provider for pre-signed URL uploads (S3, GCS, ...).
+ *
+ * All auth and URL signing is performed by the host application via the
+ * callbacks in {@link PresignedAssetProviderOptions}. The library simply
+ * PUTs/POSTs bytes to the provided URL.
+ */
+export declare class PresignedAssetProvider implements IAssetStorageProvider {
+    readonly type = "remote";
+    readonly name = "PresignedAssetProvider";
+    private _options;
+    constructor(options: PresignedAssetProviderOptions);
+    static with(options: PresignedAssetProviderOptions): {
+        create: () => IAssetStorageProvider;
+    };
+    init(): Promise<void>;
+    destroy(): void;
+    canResolve(_id: string): boolean;
+    put(blob: Blob, metadata: KritzelAssetPutMetadata): Promise<KritzelAsset>;
+    resolve(id: string): Promise<string>;
+    fetch(id: string): Promise<Blob>;
+    delete(id: string): Promise<void>;
+}

package/dist/types/classes/providers/paste-intent/event-paste-intent.provider.d.ts

@@ -0,0 +1,8 @@
+import { PasteIntent } from '../../managers/clipboard.types';
+import { KritzelPasteIntentProvider, KritzelPasteIntentProviderContext } from '../../../interfaces/paste-intent-provider.interface';
+export declare class KritzelEventPasteIntentProvider implements KritzelPasteIntentProvider {
+    canHandle(context: KritzelPasteIntentProviderContext): boolean;
+    getPasteIntent(context: KritzelPasteIntentProviderContext): Promise<PasteIntent>;
+    private parseClipboardPayload;
+    private determineTextPasteIntent;
+}

package/dist/types/classes/providers/paste-intent/ios-paste-intent.provider.d.ts

@@ -0,0 +1,6 @@
+import { PasteIntent } from '../../managers/clipboard.types';
+import { KritzelPasteIntentProvider, KritzelPasteIntentProviderContext } from '../../../interfaces/paste-intent-provider.interface';
+export declare class KritzelIosPasteIntentProvider implements KritzelPasteIntentProvider {
+    canHandle(context: KritzelPasteIntentProviderContext): boolean;
+    getPasteIntent(context: KritzelPasteIntentProviderContext): Promise<PasteIntent>;
+}

package/dist/types/classes/providers/paste-intent/navigator-paste-intent.provider.d.ts

@@ -0,0 +1,9 @@
+import { PasteIntent } from '../../managers/clipboard.types';
+import { KritzelPasteIntentProvider, KritzelPasteIntentProviderContext } from '../../../interfaces/paste-intent-provider.interface';
+export declare class KritzelNavigatorPasteIntentProvider implements KritzelPasteIntentProvider {
+    canHandle(context: KritzelPasteIntentProviderContext): boolean;
+    getPasteIntent(context: KritzelPasteIntentProviderContext): Promise<PasteIntent>;
+    private processClipboardItems;
+    private parseClipboardPayload;
+    private determineTextPasteIntent;
+}

package/dist/types/classes/providers/sync/broadcast-sync-provider.class.d.ts

@@ -0,0 +1,23 @@
+import * as Y from 'yjs';
+import { ISyncProvider } from '../../../interfaces/sync-provider.interface';
+/**
+ * BroadcastChannel sync provider for cross-tab synchronization
+ * This is a lightweight alternative to y-webrtc for browser-tab-only sync
+ */
+export declare class BroadcastSyncProvider implements ISyncProvider {
+    static readonly type: "local";
+    readonly type = "local";
+    private readonly doc;
+    private readonly channel;
+    private _synced;
+    constructor(docName: string, doc: Y.Doc, _options?: {
+        quiet?: boolean;
+    });
+    private handleDocUpdate;
+    private handleMessage;
+    private broadcastSync;
+    connect(): Promise<void>;
+    disconnect(): void;
+    reconnect(): Promise<void>;
+    destroy(): void;
+}

package/dist/types/classes/providers/sync/hocuspocus-sync-provider.class.d.ts

@@ -0,0 +1,163 @@
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+import { HocuspocusProviderWebsocket } from '@hocuspocus/provider';
+import { ISyncProvider, ProviderFactory } from '../../../interfaces/sync-provider.interface';
+/**
+ * Options for Hocuspocus sync provider
+ */
+export interface HocuspocusOptions {
+    /**
+     * Hocuspocus server URL (optional, defaults to ws://localhost:1234)
+     */
+    url?: string;
+    /**
+     * Document name (optional, defaults to docName)
+     */
+    name?: string;
+    /**
+     * Authentication token (optional)
+     */
+    token?: string | (() => string) | (() => Promise<string>);
+    /**
+     * Shared WebSocket provider for multiplexing (optional)
+     * If provided, multiple documents will share the same WebSocket connection
+     */
+    websocketProvider?: HocuspocusProviderWebsocket;
+    /**
+     * Quiet mode - suppress console output (optional, defaults to false)
+     */
+    quiet?: boolean;
+    /**
+     * Callback when connected (optional).
+     * Fires on every connection, including reconnections after a disconnect.
+     */
+    onConnect?: () => void;
+    /**
+     * Callback when disconnected (optional)
+     */
+    onDisconnect?: () => void;
+    /**
+     * Callback when synced (optional)
+     */
+    onSynced?: () => void;
+    /**
+     * Callback when authentication failed (optional)
+     */
+    onAuthenticationFailed?: (data: any) => void;
+    /**
+     * Callback when connection status changes (optional)
+     */
+    onStatus?: (data: {
+        status: string;
+    }) => void;
+    /**
+     * Force sync interval in milliseconds (optional, false to disable)
+     */
+    forceSyncInterval?: false | number;
+    /**
+     * WebSocket polyfill for Node.js environments (optional)
+     */
+    WebSocketPolyfill?: any;
+    /**
+     * Timeout in milliseconds for the initial connect() call (optional, defaults to 10000).
+     * Note: Even if the timeout fires, the underlying provider continues reconnecting in the background.
+     */
+    connectionTimeout?: number;
+    /**
+     * Base delay in milliseconds between reconnect attempts (optional, defaults to 1000)
+     */
+    delay?: number;
+    /**
+     * Exponential backoff multiplier for reconnect delay (optional, defaults to 2)
+     */
+    factor?: number;
+    /**
+     * Maximum number of reconnect attempts before giving up (optional, defaults to 0 = infinite)
+     */
+    maxAttempts?: number;
+    /**
+     * Minimum delay in milliseconds between reconnect attempts (optional)
+     */
+    minDelay?: number;
+    /**
+     * Maximum delay in milliseconds between reconnect attempts (optional)
+     */
+    maxDelay?: number;
+}
+/**
+ * Options for creating a shared WebSocket connection
+ */
+export interface HocuspocusWebSocketOptions {
+    /**
+     * Hocuspocus server URL
+     */
+    url: string;
+    /**
+     * WebSocket polyfill for Node.js environments (optional)
+     */
+    WebSocketPolyfill?: any;
+    /**
+     * Callback when WebSocket connects (optional)
+     */
+    onConnect?: () => void;
+    /**
+     * Callback when WebSocket disconnects (optional)
+     */
+    onDisconnect?: () => void;
+    /**
+     * Callback when connection status changes (optional)
+     */
+    onStatus?: (data: {
+        status: string;
+    }) => void;
+}
+export type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'synced';
+/**
+ * Hocuspocus sync provider for real-time collaboration
+ * Supports multiplexing - multiple documents can share the same WebSocket connection
+ */
+export declare class HocuspocusSyncProvider implements ISyncProvider {
+    static readonly type: "network";
+    readonly type = "network";
+    private provider;
+    private isConnected;
+    private isSynced;
+    private usesSharedSocket;
+    private isDestroyed;
+    private connectTimeout;
+    private pendingConnectReject;
+    private connectionTimeoutMs;
+    private _connectionStatus;
+    private visibilityHandler;
+    private onlineHandler;
+    get awareness(): Awareness | null;
+    get rawProvider(): unknown;
+    get connectionStatus(): ConnectionStatus;
+    private static sharedWebSocketProvider;
+    constructor(docName: string, doc: Y.Doc, options?: HocuspocusOptions);
+    private setupBrowserEventListeners;
+    private removeBrowserEventListeners;
+    /**
+     * Create a shared WebSocket connection for multiplexing
+     * Call this once to create a shared connection that multiple providers can use
+     */
+    static createSharedWebSocket(options: HocuspocusWebSocketOptions): HocuspocusProviderWebsocket;
+    /**
+     * Destroy the shared WebSocket connection
+     * Call this when you're done with all multiplexed providers
+     */
+    static destroySharedWebSocket(): void;
+    /**
+     * Get the shared WebSocket provider instance (if it exists)
+     */
+    static getSharedWebSocket(): HocuspocusProviderWebsocket | null;
+    /**
+     * Static factory method for creating HocuspocusSyncProvider with configuration options
+     * Returns a ProviderFactory that can be used in sync configuration
+     */
+    static with(options?: HocuspocusOptions): ProviderFactory;
+    connect(): Promise<void>;
+    reconnect(): Promise<void>;
+    disconnect(): void;
+    destroy(): void;
+}

package/dist/types/classes/providers/sync/in-memory-sync-provider.class.d.ts

@@ -0,0 +1,39 @@
+import * as Y from 'yjs';
+import { ISyncProvider } from '../../../interfaces/sync-provider.interface';
+/**
+ * Options for InMemory sync provider
+ */
+export interface InMemoryOptions {
+    /**
+     * Custom cache key (optional). Defaults to the docName.
+     */
+    name?: string;
+}
+/**
+ * In-memory sync provider for session-scoped persistence.
+ *
+ * State survives the component being removed from the DOM and later
+ * re-added within the same page session, but is lost on page reload.
+ * Intended for documentation demos where durable IndexedDB persistence
+ * is not desired.
+ */
+export declare class InMemorySyncProvider implements ISyncProvider {
+    static readonly type: "local";
+    readonly type = "local";
+    private readonly doc;
+    private readonly cacheKey;
+    private isConnected;
+    constructor(docName: string, doc: Y.Doc, options?: InMemoryOptions);
+    private readonly handleUpdate;
+    connect(): Promise<void>;
+    disconnect(): void;
+    reconnect(): Promise<void>;
+    destroy(): void;
+    /**
+     * Clears the in-memory cache.
+     *
+     * @param name - If provided, only the entry with this cache key is removed.
+     *               If omitted, all entries are cleared.
+     */
+    static clear(name?: string): void;
+}

package/dist/types/classes/providers/sync/indexeddb-sync-provider.class.d.ts

@@ -0,0 +1,25 @@
+import * as Y from 'yjs';
+import { ISyncProvider } from '../../../interfaces/sync-provider.interface';
+/**
+ * Options for IndexedDB sync provider
+ */
+export interface IndexedDBOptions {
+    /**
+     * Custom database name (optional)
+     */
+    name?: string;
+}
+/**
+ * IndexedDB sync provider for local persistence
+ */
+export declare class IndexedDBSyncProvider implements ISyncProvider {
+    static readonly type: "local";
+    readonly type = "local";
+    private provider;
+    private isConnected;
+    constructor(docName: string, doc: Y.Doc, options?: IndexedDBOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    reconnect(): Promise<void>;
+    destroy(): void;
+}

package/dist/types/classes/providers/sync/websocket-sync-provider.class.d.ts

@@ -0,0 +1,63 @@
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+import { ISyncProvider, ProviderFactory } from '../../../interfaces/sync-provider.interface';
+/**
+ * Options for WebSocket sync provider
+ */
+export interface WebSocketOptions {
+    /**
+     * WebSocket server URL (optional, defaults to ws://localhost:1234)
+     */
+    url?: string;
+    /**
+     * Room/document name (optional, defaults to docName)
+     */
+    roomName?: string;
+    /**
+     * Connection parameters (optional)
+     */
+    params?: Record<string, string>;
+    /**
+     * WebSocket protocols (optional)
+     */
+    protocols?: string[];
+    /**
+     * Custom WebSocket constructor (optional, for Node.js environments)
+     */
+    WebSocketPolyfill?: any;
+    /**
+     * Awareness protocol options (optional)
+     */
+    awareness?: any;
+    /**
+     * Maximum number of connection attempts (optional, defaults to Infinity)
+     */
+    maxBackoffTime?: number;
+    /**
+     * Quiet mode - suppress console output (optional, defaults to false)
+     */
+    quiet?: boolean;
+}
+/**
+ * WebSocket sync provider for real-time collaboration
+ */
+export declare class WebSocketSyncProvider implements ISyncProvider {
+    static readonly type: "network";
+    readonly type = "network";
+    private provider;
+    private isConnected;
+    private _quiet;
+    get awareness(): Awareness;
+    get rawProvider(): unknown;
+    constructor(docName: string, doc: Y.Doc, options?: WebSocketOptions);
+    /**
+     * Static factory method for creating WebSocketSyncProvider with configuration options
+     * Returns a ProviderFactory that can be used in sync configuration
+     */
+    static with(options?: WebSocketOptions): ProviderFactory;
+    private setupEventListeners;
+    connect(): Promise<void>;
+    disconnect(): void;
+    reconnect(): Promise<void>;
+    destroy(): void;
+}

package/dist/types/classes/registries/dynamic-object-renderer.registry.d.ts

@@ -0,0 +1,32 @@
+import { KritzelDynamicObjectRenderer } from "../../interfaces/dynamic-object-renderer.interface";
+/**
+ * Global registry for dynamic object renderers.
+ * Allows wrapper frameworks (Angular, React, Vue) to register renderer implementations
+ * without coupling to core, and enables deterministic rehydration across reloads and
+ * clipboard paste operations.
+ *
+ * Renderer keys are opaque strings that must be stable (e.g., 'angular-todo', 'react-editor').
+ * When a dynamic object is deserialized with a rendererKey, the registry is consulted to
+ * resolve the renderer and mount with the persisted rendererData.
+ */
+export declare class KritzelDynamicObjectRendererRegistry {
+    private static get _renderers();
+    /**
+     * Registers a renderer implementation for a given key.
+     * @param key - Stable identifier for this renderer (e.g., 'angular-my-component')
+     * @param renderer - Renderer implementation with mount/unmount/update handlers
+     */
+    static register(key: string, renderer: KritzelDynamicObjectRenderer): void;
+    /**
+     * Retrieves a registered renderer by key.
+     * @param key - Renderer identifier
+     * @returns The registered renderer, or undefined if not found
+     */
+    static get(key: string): KritzelDynamicObjectRenderer | undefined;
+    /**
+     * Unregisters a renderer by key.
+     * @param key - Renderer identifier to remove
+     * @returns True if the renderer was found and removed; false otherwise
+     */
+    static unregister(key: string): boolean;
+}

package/dist/types/classes/registries/font-registry.class.d.ts

@@ -0,0 +1,19 @@
+import { KritzelFontMap, KritzelFontRegistration, KritzelRegisteredFont } from '../../interfaces/font.interface';
+export declare class KritzelFontRegistry {
+    private static get _fonts();
+    private static getFontFaceSet;
+    private static toCssFontFace;
+    private static getRegisteredFontFamilies;
+    static register(key: string, registration: KritzelFontRegistration): void;
+    static registerFonts(fonts: KritzelFontMap): void;
+    private static injectFontStylesheets;
+    static waitForFonts(fonts: KritzelFontMap): Promise<void>;
+    static get(key: string): KritzelRegisteredFont | undefined;
+    static has(key: string): boolean;
+    static unregister(key: string): boolean;
+    static list(): KritzelRegisteredFont[];
+    static resolveCssFontFamily(fontFamily: string): string;
+    static toRegisteredFont(registration: KritzelFontRegistration): KritzelRegisteredFont;
+    private static emitChange;
+    static get changeEventName(): string;
+}

package/dist/types/classes/registries/icon-registry.class.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A static registry for managing SVG icons throughout the Kritzel library.
+ * Icons are stored as name-to-SVG-content mappings and can be retrieved by name.
+ */
+export declare class KritzelIconRegistry {
+    /** Internal storage for registered icons, mapping icon names to their SVG content. */
+    private static registry;
+    /**
+     * Registers a single icon with the given name and SVG content.
+     * If an icon with the same name already exists, it will be overwritten and a warning will be logged.
+     *
+     * @param name - The unique identifier for the icon.
+     * @param svgContent - The SVG markup string representing the icon.
+     */
+    static register(name: string, svgContent: string): void;
+    /**
+     * Retrieves the SVG content for a registered icon by its name.
+     *
+     * @param name - The unique identifier of the icon to retrieve.
+     * @returns The SVG markup string if the icon exists, or `undefined` if not found.
+     */
+    static get(name: string): string | undefined;
+    /**
+     * Registers multiple icons at once from an object mapping names to SVG content.
+     * This is a convenience method for bulk registration.
+     *
+     * @param icons - An object where keys are icon names and values are SVG markup strings.
+     */
+    static registerIcons(icons: {
+        [key: string]: string;
+    }): void;
+    /**
+     * Checks whether an icon with the given name is registered.
+     *
+     * @param name - The unique identifier of the icon to check.
+     * @returns `true` if the icon exists in the registry, `false` otherwise.
+     */
+    static has(name: string): boolean;
+}

package/dist/types/classes/registries/paste-intent-provider.registry.d.ts

@@ -0,0 +1,10 @@
+import { KritzelCore } from '../core/core.class';
+import { PasteIntent } from '../managers/clipboard.types';
+import { KritzelPasteIntentProvider } from '../../interfaces/paste-intent-provider.interface';
+export declare class KritzelPasteIntentProviderRegistry {
+    private readonly _core;
+    private readonly _providers;
+    constructor(_core: KritzelCore);
+    register(provider: KritzelPasteIntentProvider): void;
+    resolve(event?: ClipboardEvent): Promise<PasteIntent>;
+}