superdoc 2.29.0-next.3 → 2.29.0

package/dist/superdoc/src/core/whiteboard/WhiteboardPage.d.ts

@@ -1,210 +1,31 @@
-/**
- * @typedef {{ width: number, height: number, originalWidth?: number, originalHeight?: number }} WhiteboardPageSize
- * @typedef {{ x: number, y: number }} Point
- *
- * Authored input shapes — what `addStroke`/`addText`/`addImage` accept
- * from a consumer (pixel-space coordinates, optional ids). The
- * add* methods normalize these into the stored shapes below.
- *
- * @typedef {{ points: number[][], color?: string, width?: number, type?: 'draw'|'erase' }} WhiteboardStroke
- * @typedef {{ id?: string|number, x: number, y: number, content: string, fontSize?: number, width?: number }} WhiteboardTextItem
- * @typedef {{ id?: string|number, stickerId?: string, x: number, y: number, src: string, width?: number, height?: number, type?: string }} WhiteboardImageItem
- *
- * Stored / normalized shapes — what the page actually holds in
- * `this.strokes` / `this.text` / `this.images` and what gets
- * serialized via `toJSON()` and re-applied via `applyData()`. Fields
- * suffixed with `N` (pointsN, xN, yN, widthN, heightN, fontSizeN) are
- * normalized to the page's 0..1 coordinate space; raw `width`/`height`
- * pairs are kept where consumers expect pixel sizes.
- *
- * SD-3213 follow-up: the public types were previously `any[]` for the
- * fields and the toJSON / applyData signatures; consumers reading
- * `page.strokes[0].points` would have hit pointsN at runtime with no
- * IntelliSense. The named shapes below restore typing without
- * over-committing the authored shapes (which the add* methods
- * normalize away).
- *
- * @typedef {{ pointsN: number[][], widthN?: number, color?: string, type?: 'draw'|'erase' }} WhiteboardStoredStroke
- * @typedef {{ id: string|number, xN: number, yN: number, content: string, fontSizeN?: number, widthN?: number | null }} WhiteboardStoredTextItem
- * @typedef {{ id: string|number, stickerId?: string | number | null, xN: number, yN: number, src: string, widthN?: number | null, heightN?: number | null, type?: string }} WhiteboardStoredImageItem
- *
- * @typedef {{
- *  strokes?: WhiteboardStoredStroke[],
- *  text?: WhiteboardStoredTextItem[],
- *  images?: WhiteboardStoredImageItem[],
- * }} WhiteboardStoredPageData
- *
- * @typedef {{
- *  pageIndex: number,
- *  enabled: boolean,
- *  Renderer: any,
- *  onChange?: () => void,
- *  onToolChange?: (tool: string) => void,
- * }} WhiteboardPageInit
- */
-/**
- * Per-page whiteboard renderer/controller.
- */
-export class WhiteboardPage {
-    /**
-     * Create a page controller.
-     * @param {WhiteboardPageInit} props
-     */
-    constructor(props: WhiteboardPageInit);
-    /** @type {number|null} */
-    pageIndex: number | null;
-    /** @type {WhiteboardStoredStroke[]} */
-    strokes: WhiteboardStoredStroke[];
-    /** @type {WhiteboardStoredTextItem[]} */
-    text: WhiteboardStoredTextItem[];
-    /** @type {WhiteboardStoredImageItem[]} */
-    images: WhiteboardStoredImageItem[];
-    /** @type {WhiteboardPageSize|null} */
-    size: WhiteboardPageSize | null;
-    /** @type {{ width: number|null, height: number|null }|null} */
-    originalSize: {
-        width: number | null;
-        height: number | null;
-    } | null;
-    /**
-     * Set tool for this page.
-     * @param {string} tool
-     */
-    setTool(tool: string): void;
-    /**
-     * Get current tool for this page.
-     * @returns {string}
-     */
-    getTool(): string;
-    /**
-     * Enable/disable interactivity for this page.
-     * @param {boolean} enabled
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * @returns {boolean}
-     */
-    isEnabled(): boolean;
-    /**
-     * Store page size (does not resize canvas).
-     * @param {WhiteboardPageSize} size
-     */
-    setSize(size: WhiteboardPageSize): void;
-    /**
-     * Resize the Konva stage.
-     * @param {number} width
-     * @param {number} height
-     */
-    resize(width: number, height: number): void;
-    /**
-     * Mount Konva stage into a container.
-     * @param {HTMLElement} container
-     */
-    mount(container: HTMLElement): void;
-    /**
-     * Re-render all content for this page.
-     */
-    render(): void;
-    /**
-     * Render stroke paths.
-     */
-    renderStrokes(): void;
-    /**
-     * Render text nodes.
-     */
-    renderText(): void;
-    /**
-     * Render image/sticker nodes.
-     * NOTE: Images are reconciled by id to avoid re-creating nodes (prevents flicker).
-     * If src changes for an existing id, this path does not reload the image.
-     */
-    renderImages(): void;
-    /**
-     * Destroy Konva stage and clean up listeners.
-     */
-    destroy(): void;
-    /**
-     * Serialize page data.
-     * Returns the page's serializable shape. SD-3213 follow-up: fixed
-     * stale JSDoc that said `stickers` (which never existed on the
-     * runtime return) and typed the values as the stored normalized
-     * shapes instead of `any[]`.
-     *
-     * @returns {{ strokes: WhiteboardStoredStroke[], text: WhiteboardStoredTextItem[], images: WhiteboardStoredImageItem[] }}
-     */
-    toJSON(): {
-        strokes: WhiteboardStoredStroke[];
-        text: WhiteboardStoredTextItem[];
-        images: WhiteboardStoredImageItem[];
-    };
-    /**
-     * Apply data to this page and re-render.
-     * @param {WhiteboardStoredPageData} data
-     */
-    applyData(data?: WhiteboardStoredPageData): void;
-    /**
-     * Add a stroke to the model.
-     * @param {WhiteboardStroke} stroke
-     */
-    addStroke(stroke: WhiteboardStroke): void;
-    /**
-     * Add a text item to the model.
-     * @param {WhiteboardTextItem} item
-     */
-    addText(item: WhiteboardTextItem): void;
-    /**
-     * Add an image/sticker to the model.
-     * @param {WhiteboardImageItem} item
-     */
-    addImage(item: WhiteboardImageItem): void;
-    #private;
-}
 export type WhiteboardPageSize = {
     width: number;
     height: number;
     originalWidth?: number;
     originalHeight?: number;
 };
-/**
- * Authored input shapes — what `addStroke`/`addText`/`addImage` accept
- * from a consumer (pixel-space coordinates, optional ids). The
- * add* methods normalize these into the stored shapes below.
- */
 export type Point = {
     x: number;
     y: number;
 };
+export type WhiteboardItemId = string | number;
+export type WhiteboardStrokeType = 'draw' | 'erase';
 export type WhiteboardStroke = {
     points: number[][];
     color?: string;
     width?: number;
-    type?: "draw" | "erase";
+    type?: WhiteboardStrokeType;
 };
 export type WhiteboardTextItem = {
-    id?: string | number;
+    id?: WhiteboardItemId;
     x: number;
     y: number;
     content: string;
     fontSize?: number;
     width?: number;
 };
-/**
- * Stored / normalized shapes — what the page actually holds in
- * `this.strokes` / `this.text` / `this.images` and what gets
- * serialized via `toJSON()` and re-applied via `applyData()`. Fields
- * suffixed with `N` (pointsN, xN, yN, widthN, heightN, fontSizeN) are
- * normalized to the page's 0..1 coordinate space; raw `width`/`height`
- * pairs are kept where consumers expect pixel sizes.
- *
- * SD-3213 follow-up: the public types were previously `any[]` for the
- * fields and the toJSON / applyData signatures; consumers reading
- * `page.strokes[0].points` would have hit pointsN at runtime with no
- * IntelliSense. The named shapes below restore typing without
- * over-committing the authored shapes (which the add* methods
- * normalize away).
- */
 export type WhiteboardImageItem = {
-    id?: string | number;
+    id?: WhiteboardItemId;
     stickerId?: string;
     x: number;
     y: number;
@@ -217,10 +38,10 @@ export type WhiteboardStoredStroke = {
     pointsN: number[][];
     widthN?: number;
     color?: string;
-    type?: "draw" | "erase";
+    type?: WhiteboardStrokeType;
 };
 export type WhiteboardStoredTextItem = {
-    id: string | number;
+    id: WhiteboardItemId;
     xN: number;
     yN: number;
     content: string;
@@ -228,8 +49,8 @@ export type WhiteboardStoredTextItem = {
     widthN?: number | null;
 };
 export type WhiteboardStoredImageItem = {
-    id: string | number;
-    stickerId?: string | number | null;
+    id: WhiteboardItemId;
+    stickerId?: WhiteboardItemId | null;
     xN: number;
     yN: number;
     src: string;
@@ -242,10 +63,163 @@ export type WhiteboardStoredPageData = {
     text?: WhiteboardStoredTextItem[];
     images?: WhiteboardStoredImageItem[];
 };
+export type WhiteboardSerializedPage = {
+    strokes: WhiteboardStoredStroke[];
+    text: WhiteboardStoredTextItem[];
+    images: WhiteboardStoredImageItem[];
+};
+export type WhiteboardRendererEvent = {
+    target?: unknown;
+    cancelBubble?: boolean;
+};
+export interface WhiteboardRendererNode {
+    _whiteboardId?: WhiteboardItemId;
+    on(events: string, handler: (event: WhiteboardRendererEvent) => void): unknown;
+    destroy(): unknown;
+    name(): string;
+    name(name: string): unknown;
+}
+export interface WhiteboardShapeNode extends WhiteboardRendererNode {
+    x(): number;
+    x(value: number): unknown;
+    y(): number;
+    y(value: number): unknown;
+    width(): number;
+    width(value: number): unknown;
+    height(): number;
+    height(value: number): unknown;
+    scaleX(): number;
+    scaleY(): number;
+    scale(scale: Point): unknown;
+    draggable(value: boolean): unknown;
+    position(): Point;
+}
+export interface WhiteboardTextNode extends WhiteboardShapeNode {
+    scaleY(): number;
+    scaleY(value: number): unknown;
+    setAttrs(attrs: {
+        width: number;
+        scaleX: number;
+        scaleY?: number;
+    }): unknown;
+    text(): string;
+    text(value: string): unknown;
+    fontSize(): number;
+    fontFamily(): string;
+    fill(): string | CanvasGradient;
+}
+export interface WhiteboardLineNode extends WhiteboardRendererNode {
+    points(points: number[]): unknown;
+}
+export type WhiteboardBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+};
+export type WhiteboardBoundBoxFunc = (oldBox: WhiteboardBox, newBox: WhiteboardBox) => WhiteboardBox;
+export interface WhiteboardTransformerNode {
+    destroy(): unknown;
+    nodes(nodes: WhiteboardShapeNode[]): unknown;
+    enabledAnchors(anchors: string[]): unknown;
+    boundBoxFunc(fn: WhiteboardBoundBoxFunc): unknown;
+}
+export interface WhiteboardLayerNode {
+    add(child: WhiteboardRendererNode | WhiteboardTransformerNode): unknown;
+    find(selector: string): WhiteboardShapeNode[];
+    destroyChildren(): unknown;
+    batchDraw(): unknown;
+    listening(listening: boolean): unknown;
+    getCanvas(): {
+        setPixelRatio(ratio: number): unknown;
+    };
+}
+export interface WhiteboardStageNode {
+    on(events: string, handler: (event: WhiteboardRendererEvent) => void): unknown;
+    add(layer: WhiteboardLayerNode): unknown;
+    size(size: {
+        width: number;
+        height: number;
+    }): unknown;
+    getPointerPosition(): Point | null;
+    destroy(): unknown;
+}
+export type WhiteboardLineConfig = {
+    points: number[];
+    stroke: string;
+    strokeWidth: number;
+    lineCap: 'round';
+    lineJoin: 'round';
+    globalCompositeOperation: 'destination-out' | 'source-over';
+};
+export interface WhiteboardPageRenderer {
+    Stage: new (config: {
+        container: HTMLDivElement;
+        width: number;
+        height: number;
+    }) => WhiteboardStageNode;
+    Layer: new () => WhiteboardLayerNode;
+    Line: new (config: WhiteboardLineConfig) => WhiteboardLineNode;
+    Text: new (config: {
+        x: number;
+        y: number;
+        text: string;
+        fontSize: number;
+        fontFamily: string;
+        fill: string;
+        draggable: boolean;
+        width: number | undefined;
+    }) => WhiteboardTextNode;
+    Image: new (config: {
+        x: number;
+        y: number;
+        image: HTMLImageElement;
+        width: number;
+        height: number;
+        draggable: boolean;
+    }) => WhiteboardShapeNode;
+    Transformer: new (config: {
+        enabledAnchors: string[];
+        rotateEnabled: boolean;
+        keepRatio: boolean;
+        boundBoxFunc: WhiteboardBoundBoxFunc;
+    }) => WhiteboardTransformerNode;
+}
 export type WhiteboardPageInit = {
     pageIndex: number;
     enabled: boolean;
-    Renderer: any;
+    Renderer?: WhiteboardPageRenderer;
     onChange?: () => void;
     onToolChange?: (tool: string) => void;
 };
+export declare class WhiteboardPage {
+    #private;
+    pageIndex: number;
+    strokes: WhiteboardStoredStroke[];
+    text: WhiteboardStoredTextItem[];
+    images: WhiteboardStoredImageItem[];
+    size: WhiteboardPageSize | null;
+    originalSize: {
+        width: number | null;
+        height: number | null;
+    } | null;
+    constructor(props: WhiteboardPageInit);
+    setTool(tool: string): void;
+    getTool(): string;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    setSize(size: WhiteboardPageSize): void;
+    resize(width: number, height: number): void;
+    mount(container: HTMLDivElement): void;
+    render(): void;
+    renderStrokes(): void;
+    renderText(): void;
+    renderImages(): void;
+    destroy(): void;
+    toJSON(): WhiteboardSerializedPage;
+    applyData(data?: WhiteboardStoredPageData): void;
+    addStroke(stroke: WhiteboardStroke): void;
+    addText(item: WhiteboardTextItem): void;
+    addImage(item: WhiteboardImageItem): void;
+}

package/dist/superdoc/src/core/whiteboard/helpers/createTextarea.d.ts

@@ -1 +1,14 @@
-export function createTextarea(options?: {}): HTMLTextAreaElement;
+export type TextareaSize = number | string;
+export interface TextareaOptions {
+    value?: string;
+    left?: number;
+    top?: number;
+    width?: TextareaSize;
+    height?: TextareaSize;
+    fontSize?: TextareaSize;
+    fontFamily?: string;
+    color?: string;
+    background?: string;
+    resize?: string;
+}
+export declare function createTextarea(options?: TextareaOptions): HTMLTextAreaElement;

package/dist/superdoc/src/core/whiteboard/helpers/flattenPoints.d.ts

@@ -1 +1 @@
-export function flattenPoints(points: any): any;
+export declare function flattenPoints(points: readonly (readonly number[])[]): number[];

package/dist/superdoc/src/core/whiteboard/helpers/getRandomId.d.ts

@@ -1 +1 @@
-export function getRandomId(prefix?: string): string;
+export declare function getRandomId(prefix?: string): string;

package/dist/superdoc/src/helpers/comment-focus.d.ts

@@ -1,4 +1,21 @@
-export function getPreferredCommentFocusTargetClientY(): number;
-export function getVisibleThreadAnchorClientY(layersElement: any, positionEntry: any): any;
-export function getVisibleThreadHighlightClientY(threadIds: any): any;
-export function scrollThreadAnchorToFocusTarget(presentation: any, primaryThreadId: any, fallbackThreadId: any, targetClientY: any): any;
+type ClientRectSource = {
+    getBoundingClientRect?: () => {
+        top: number;
+    };
+};
+type ThreadPositionEntry = {
+    bounds?: {
+        top?: number;
+    } | null;
+} | null | undefined;
+type ThreadAnchorPresentation = {
+    getReachableThreadAnchorClientY: (threadId: string, targetClientY: number) => number | null | undefined;
+    scrollThreadAnchorToClientY: (threadId: string, targetClientY: number, options: {
+        behavior: ScrollBehavior;
+    }) => boolean | null | undefined;
+};
+export declare const getPreferredCommentFocusTargetClientY: () => number;
+export declare const getVisibleThreadAnchorClientY: (layersElement: ClientRectSource | null | undefined, positionEntry: ThreadPositionEntry) => number | null;
+export declare const getVisibleThreadHighlightClientY: (threadIds: ReadonlyArray<string | number | null | undefined> | null | undefined) => number | null;
+export declare const scrollThreadAnchorToFocusTarget: (presentation: ThreadAnchorPresentation | null | undefined, primaryThreadId: string | null | undefined, fallbackThreadId: string | null | undefined, targetClientY: number | null | undefined) => number | null;
+export {};

package/dist/superdoc/src/helpers/deprecation.d.ts

@@ -1,9 +1,8 @@
+import { Editor } from '../core/types/index.js';
 /**
  * Log a console.warn once per key. Subsequent calls with the same key are no-ops.
- * @param {string} key
- * @param {string} message
  */
-export function warnOnce(key: string, message: string): void;
+export declare function warnOnce(key: string, message: string): void;
 /**
  * Wrap an Editor instance in a Proxy that emits one-time deprecation
  * warnings when consumers access ProseMirror internals or editor commands.
@@ -11,16 +10,11 @@ export function warnOnce(key: string, message: string): void;
  * The proxy is fully transparent — all property access and method calls are
  * forwarded to the underlying editor. Only the warning side-effect is added.
  *
- * @param {import('../core/types/index.js').Editor} editor
- * @returns {import('../core/types/index.js').Editor} Proxied editor (or the
- *   original if null/already wrapped)
+ * @returns Proxied editor (or the original if null/already wrapped)
  */
-export function createDeprecatedEditorProxy(editor: import('../core/types/index.js').Editor): import('../core/types/index.js').Editor;
+export declare function createDeprecatedEditorProxy<T extends Editor | null | undefined>(editor: T): T;
 /**
  * Unwrap a potentially proxied editor back to the raw Editor instance.
  * Safe to call on an already-raw editor — returns it unchanged.
- *
- * @param {import('../core/types/index.js').Editor | null | undefined} editor
- * @returns {import('../core/types/index.js').Editor | null | undefined}
  */
-export function unwrapEditor(editor: import('../core/types/index.js').Editor | null | undefined): import('../core/types/index.js').Editor | null | undefined;
+export declare function unwrapEditor(editor: Editor | null | undefined): Editor | null | undefined;

package/dist/superdoc/src/helpers/interaction-trace.d.ts

@@ -1,26 +1,9 @@
-/**
- * @param {string} stage
- * @param {string} branch
- * @param {Record<string, unknown> | undefined} [meta]
- * @returns {{ traceId: string, spanId: string } | null}
- */
-export function startInteractionSpan(stage: string, branch: string, meta?: Record<string, unknown> | undefined): {
+type InteractionSpan = {
     traceId: string;
     spanId: string;
-} | null;
-/**
- * @param {{ traceId: string, spanId: string } | null | undefined} span
- * @param {Record<string, unknown> | undefined} [meta]
- */
-export function endInteractionSpan(span: {
-    traceId: string;
-    spanId: string;
-} | null | undefined, meta?: Record<string, unknown> | undefined): void;
-/**
- * @param {string} stage
- * @param {string} branch
- * @param {Record<string, unknown> | undefined} meta
- * @param {() => any} fn
- * @returns {any}
- */
-export function withInteractionSpan(stage: string, branch: string, meta: Record<string, unknown> | undefined, fn: () => any): any;
+};
+type InteractionMeta = Record<string, unknown> | undefined;
+export declare function startInteractionSpan(stage: string, branch: string, meta?: InteractionMeta): InteractionSpan | null;
+export declare function endInteractionSpan(span: InteractionSpan | null | undefined, meta?: InteractionMeta): void;
+export declare function withInteractionSpan<T>(stage: string, branch: string, meta: InteractionMeta, fn: () => T): T;
+export {};

package/dist/superdoc/src/helpers/mark-raw-component.d.ts

@@ -0,0 +1 @@
+export declare function markRawComponent(component: unknown): unknown;

package/dist/superdoc/src/helpers/object-guards.d.ts

@@ -1,5 +1,2 @@
-/**
- * @param {unknown} value
- * @returns {value is Record<string, unknown>}
- */
-export function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;

package/dist/superdoc/src/helpers/selection-source.d.ts

@@ -1 +1 @@
-export const DOCUMENT_EDITOR_SELECTION_SOURCE: "document-editor";
+export declare const DOCUMENT_EDITOR_SELECTION_SOURCE = "document-editor";

package/dist/superdoc/src/helpers/use-selection.d.ts

@@ -1,17 +1,37 @@
-export default function useSelection(params: any): {
-    documentId: import('vue').Ref<any, any>;
-    page: import('vue').Ref<any, any>;
-    selectionBounds: any;
-    source: import('vue').Ref<any, any>;
-    getValues: () => {
-        documentId: any;
-        page: any;
-        selectionBounds: any;
-        source: any;
-    };
+import { Ref } from 'vue';
+type SelectionBounds = {
+    top?: number;
+    left?: number;
+    right?: number;
+    bottom?: number;
+};
+type UseSelectionParams = {
+    documentId?: unknown;
+    page?: number;
+    selectionBounds?: SelectionBounds | null;
+    source?: string | null;
+};
+type ContainerLocation = {
+    top: number;
+    left: number;
+};
+type SelectionValues<Bounds extends SelectionBounds> = {
+    documentId: unknown;
+    page: number | undefined;
+    selectionBounds: Bounds;
+    source: string | null | undefined;
+};
+type SelectionModel<Bounds extends SelectionBounds> = {
+    documentId: Ref<unknown>;
+    page: Ref<number | undefined>;
+    selectionBounds: Bounds;
+    source: Ref<string | null | undefined>;
+    getValues: () => SelectionValues<Bounds>;
     getContainerId: () => string;
-    getContainerLocation: (parentContainer: any) => {
-        top: number;
-        left: number;
-    };
+    getContainerLocation: (parentContainer: Pick<Element, 'getBoundingClientRect'> | null | undefined) => ContainerLocation;
 };
+export default function useSelection<Bounds extends SelectionBounds>(params: UseSelectionParams & {
+    selectionBounds: Bounds;
+}): SelectionModel<Bounds>;
+export default function useSelection(params: UseSelectionParams): SelectionModel<SelectionBounds>;
+export {};

package/dist/superdoc/src/helpers/v2-author-required-rejection.d.ts

@@ -1,16 +1,13 @@
-/**
- * @param {any} event - a `v2-host-event` payload.
- * @returns {boolean} true when the rejection means the session needs an author.
- */
-export function isV2AuthorRequiredRejection(event: any): boolean;
-export function createV2AuthorRequiredNotificationGate(): {
-    shouldNotify(scope: any, event: any): boolean;
-    clear(scope: any): void;
-};
+import { V2MutationRejectedEvent } from './v2-mutation-exception.js';
 /** Stable, non-terminal exception code surfaced to consumers. */
-export const V2_AUTHOR_REQUIRED_CODE: "author-required";
+export declare const V2_AUTHOR_REQUIRED_CODE = "author-required";
 /**
  * Content-safe, actionable message. Contains no document text, imported author,
  * email, path, or source key — only how to fix the configuration.
  */
-export const V2_AUTHOR_REQUIRED_MESSAGE: "This edit needs an author identity. Set `user.name` in your SuperDoc configuration and reopen the document to make tracked or revision-overlapping edits.";
+export declare const V2_AUTHOR_REQUIRED_MESSAGE = "This edit needs an author identity. Set `user.name` in your SuperDoc configuration and reopen the document to make tracked or revision-overlapping edits.";
+export declare function isV2AuthorRequiredRejection(event: unknown): event is V2MutationRejectedEvent;
+export declare function createV2AuthorRequiredNotificationGate(): {
+    shouldNotify(scope: string | null | undefined, event: unknown): boolean;
+    clear(scope: string | null | undefined): void;
+};

package/dist/superdoc/src/helpers/v2-bulk-decision-event.d.ts

@@ -1,7 +1,9 @@
-export function toV2BulkDecisionEvent(documentId: any, fact: any): {
-    documentId: string | null;
-    decision: any;
-    requestedCount: any;
-    successfulCount: any;
-    permissionDeniedCount: any;
-} | null;
+import { SuperDocTrackedChangesBulkDecisionPayload } from '../core/types/index.js';
+export type V2TrackedChangeBulkDecisionFact = {
+    schemaVersion: number;
+    decision: string;
+    requestedCount: number;
+    appliedCount: number;
+    deniedCount: number;
+};
+export declare function toV2BulkDecisionEvent(documentId: string | null | undefined, fact: V2TrackedChangeBulkDecisionFact | null | undefined): SuperDocTrackedChangesBulkDecisionPayload | null;

package/dist/superdoc/src/helpers/v2-keyboard-edit-rejection.d.ts

@@ -1,13 +1,14 @@
-export function isV2KeyboardEditRejection(event: any): boolean;
-export function createV2KeyboardEditRejectionException(documentId: any, event: any): {
+import { V2MutationRejectedEvent } from './v2-mutation-exception.js';
+export declare const V2_EDIT_REJECTED_CODE = "edit-rejected";
+export declare const V2_EDIT_REJECTED_MESSAGE = "This edit couldn\u2019t be completed. Adjust the selection and try again.";
+export declare function isV2KeyboardEditRejection(event: unknown): event is V2MutationRejectedEvent;
+export declare function createV2KeyboardEditRejectionException(documentId: string | null | undefined, event?: unknown): {
     documentId?: string | undefined;
     error: Error;
     code: string;
     editor: null;
 };
-export function createV2KeyboardEditRejectionNotificationGate(): {
-    shouldNotify(scope: any, event: any): boolean;
-    clear(scope: any): void;
+export declare function createV2KeyboardEditRejectionNotificationGate(): {
+    shouldNotify(scope: string | null | undefined, event: unknown): boolean;
+    clear(scope: string | null | undefined): void;
 };
-export const V2_EDIT_REJECTED_CODE: "edit-rejected";
-export const V2_EDIT_REJECTED_MESSAGE: "This edit couldn\u2019t be completed. Adjust the selection and try again.";