superdoc 2.28.0 → 2.29.0-next.13

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/is-finite-number.d.ts

@@ -0,0 +1 @@
+export declare function isFiniteNumber(value: unknown): value is number;

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 @@
-/**
- * @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>;

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.";

package/dist/superdoc/src/helpers/v2-mutation-exception.d.ts

@@ -1,10 +1,14 @@
-export function createV2MutationRejectionCause(event: any): {
-    editableCommandKind?: any;
-    inputKind?: any;
-    reason?: string | undefined;
-    failureSource?: any;
+export type V2MutationRejectedEvent = Record<string, unknown> & {
+    type: 'mutation:rejected';
 };
-export function createV2MutationRejectionNotificationGate(matches: any): {
-    shouldNotify(scope: any, event: any): boolean;
-    clear(scope: any): void;
+export type V2MutationRejectionCause = {
+    failureSource?: string;
+    reason?: string;
+    inputKind?: string;
+    editableCommandKind?: string;
+};
+export declare function createV2MutationRejectionCause(event: unknown): V2MutationRejectionCause;
+export declare function createV2MutationRejectionNotificationGate(matches: (event: unknown) => event is V2MutationRejectedEvent): {
+    shouldNotify(scope: string | null | undefined, event: unknown): boolean;
+    clear(scope: string | null | undefined): void;
 };

package/dist/superdoc/src/helpers/v2-review-target.d.ts

@@ -1,7 +1,17 @@
+type V2ReviewTargetInput = {
+    entityId?: unknown;
+    entityType?: unknown;
+};
+type V2ReviewTargetComment = {
+    trackedChange?: unknown;
+    commentId?: unknown;
+    importedId?: unknown;
+};
 /**
  * Resolve the comments-store identity for a document-origin v2 review target.
  * Painted review carriers can become interactive before the asynchronous row
  * hydration finishes. In that window the host's canonical entity id remains
  * the correct pending active identity; once hydrated, the row aliases win.
  */
-export function resolveV2ReviewTargetCommentId(target: any, getComment: any): any;
+export declare function resolveV2ReviewTargetCommentId(target: V2ReviewTargetInput | null | undefined, getComment: ((id: string) => V2ReviewTargetComment | null | undefined) | null | undefined): string | null;
+export {};

package/dist/superdoc/src/helpers/v2-selection-sync.d.ts

@@ -1,15 +1,41 @@
-export function isV2RangeSnapshot(snapshot: {
-    anchor?: {
-        blockId?: unknown;
-        blockOffset?: unknown;
-    };
-    focus?: {
-        blockId?: unknown;
-        blockOffset?: unknown;
-    };
-} | null | undefined): boolean;
-export function hasOutsideV2DomRangeSelection(selection: Selection | null | undefined, root: Node | null | undefined): boolean;
-export function shouldPreserveHostV2Selection(documentMode: string | null | undefined, hostSnapshot: unknown): boolean;
-export function shouldRetainV2FloatingSelection(hasHostRange: boolean, selectionPosition: {
+type V2SelectionPoint = {
+    blockId?: unknown;
+    blockOffset?: unknown;
+};
+type V2RangeSnapshotInput = {
+    anchor?: V2SelectionPoint | null;
+    focus?: V2SelectionPoint | null;
+};
+/**
+ * A logical v2 selection snapshot represents a non-empty range when its anchor
+ * and focus point at different block positions. Mirrors the range check the v2
+ * shell uses when it emits `v2-selection-changed`.
+ */
+export declare const isV2RangeSnapshot: (snapshot: V2RangeSnapshotInput | null | undefined) => boolean;
+/**
+ * Detect a real browser text selection whose endpoints are outside the active
+ * v2 mount. Editable host selections can have no native DOM range, so an
+ * absent range must not count as an outside selection.
+ */
+export declare const hasOutsideV2DomRangeSelection: (selection: Selection | null | undefined, root: Node | null | undefined) => boolean;
+/**
+ * Decide whether the DOM-selection sync pass should keep the affordance driven
+ * by the v2 host's logical selection instead of clearing it.
+ *
+ * In editable modes the host owns pointer text selection, so native DOM ranges
+ * may be absent or stale. In that case the pointerup sync must defer to the
+ * host snapshot rather than clobber the selection the host just published.
+ * Only editable modes use the host snapshot. Viewing mode keeps native DOM
+ * selection, and unknown modes should not preserve stale host state.
+ */
+export declare const shouldPreserveHostV2Selection: (documentMode: string | null | undefined, hostSnapshot: V2RangeSnapshotInput | null | undefined) => boolean;
+/**
+ * A V2 paint can briefly have no DOM anchor while a selected control is being
+ * rebuilt. Keep an already-positioned comment affordance during that gap when
+ * the host still owns a range; otherwise the button unmounts and remounts on
+ * consecutive paint frames, making it blink and intercepting its own click.
+ */
+export declare const shouldRetainV2FloatingSelection: (hasHostRange: boolean, selectionPosition: {
     source?: unknown;
-} | null | undefined): boolean;
+} | null | undefined) => boolean;
+export {};

package/dist/superdoc/src/helpers/v2-typing-mutation-event.d.ts

@@ -1,5 +1,14 @@
-export function isV2EditableTextMutationEvent(event: {
-    type?: string;
-    origin?: string;
-    editableCommandKind?: string;
-} | null | undefined): boolean;
+/**
+ * True when a forwarded v2 host event is a committed editable-input mutation
+ * of the sustained-typing class, i.e. review-row hydration for it should be
+ * debounced rather than fired immediately.
+ *
+ * Events without a forwarded `editableCommandKind` (programmatic Document API
+ * mutations, history commits, unclassified structural commands) return false
+ * so they keep hydrating immediately.
+ */
+export declare const isV2EditableTextMutationEvent: (event: {
+    type?: unknown;
+    origin?: unknown;
+    editableCommandKind?: unknown;
+} | null | undefined) => boolean;

package/dist/superdoc/src/icons.d.ts

@@ -1,11 +1,11 @@
-export namespace superdocIcons {
-    export { commentIconSvg as comment };
-    export { caretDownIconSvg as caretDown };
-    export { userCheckIconSvg as internal };
-    export { usersIconSvg as external };
-    export { checkIconSvg as markDone };
-    export { checkIconSvg as acceptChange };
-    export { xmarkIconSvg as rejectChange };
-    export { ellipsisVerticalSvg as overflow };
-    export { rotateLeftSvg as reopen };
-}
+export declare const superdocIcons: {
+    comment: string;
+    caretDown: string;
+    internal: string;
+    external: string;
+    markDone: string;
+    acceptChange: string;
+    rejectChange: string;
+    overflow: string;
+    reopen: string;
+};

package/dist/superdoc/src/internal/diagnostics/diagnostic-dedupe.d.ts

@@ -11,13 +11,13 @@
  * come from the shell, not be inferred from `onV2EditorReady` timing: that
  * event only fires on success, fires AFTER the diagnostics events on the
  * success path, and never fires at all for a failed attempt.
- *
- * @param {{generation?: unknown}} [payload]
- * @returns {number}
  */
-export function getV2DiagnosticGeneration(payload?: {
+export declare function getV2DiagnosticGeneration(payload?: {
     generation?: unknown;
-}): number;
+} | null): number;
+export interface V2DiagnosticDedupe {
+    shouldEmit(documentId: string | null | undefined, generation: number, internalCode: string | null | undefined): boolean;
+}
 /**
  * Creates a dedupe tracker for diagnostic emissions, scoped by documentId
  * and generation. The key is `internalCode` only (per active generation) --
@@ -43,12 +43,8 @@ export function getV2DiagnosticGeneration(payload?: {
  * a long-lived SuperDoc instance's life (e.g. a document-management app
  * cycling through many files); evicting on document removal would need to
  * hook document-lifecycle wiring, which is out of scope here.
- *
- * @returns {{ shouldEmit: (documentId: string | null | undefined, generation: number, internalCode: string | null | undefined) => boolean }}
  */
-export function createV2DiagnosticDedupe(): {
-    shouldEmit: (documentId: string | null | undefined, generation: number, internalCode: string | null | undefined) => boolean;
-};
+export declare function createV2DiagnosticDedupe(): V2DiagnosticDedupe;
 /**
  * A single boot failure can translate to a generic reason-based diagnostic
  * (`translateBootFailureReason`, e.g. `source-load-failed` -> `PARSE_ERROR`)
@@ -61,12 +57,7 @@ export function createV2DiagnosticDedupe(): {
  * `bootErrorName`-classified diagnostic (render-pipeline signal, not
  * package-integrity) is never redundant this way, since it carries genuinely
  * distinct information from the package diagnostics.
- *
- * @param {{internalCode?: string} | null} bootDiagnostic
- * @param {string} reason
- * @param {readonly unknown[]} translatedRecords
- * @returns {boolean}
  */
-export function isBootDiagnosticRedundant(bootDiagnostic: {
+export declare function isBootDiagnosticRedundant(bootDiagnostic: {
     internalCode?: string;
 } | null, reason: string, translatedRecords: readonly unknown[]): boolean;

package/dist/superdoc/src/internal/toolbar/built-in/AIWriter.vue.d.ts

@@ -1,21 +1,82 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    target: Record<string, any>;
-    doc: Record<string, any>;
+import { PropType } from 'vue';
+import { SelectionTarget } from '../../../../../document-api/src/index.js';
+interface AiWriterDocument {
+    replace?: (input: {
+        target: SelectionTarget;
+        text: string;
+    }) => unknown;
+    insert?: (input: {
+        target?: SelectionTarget;
+        value: string;
+        type: 'text';
+    }) => unknown;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    selectedText: {
+        type: StringConstructor;
+        default: string;
+    };
+    target: {
+        type: PropType<SelectionTarget | null>;
+        default: null;
+    };
+    doc: {
+        type: PropType<AiWriterDocument | null>;
+        default: null;
+    };
+    apiKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    endpoint: {
+        type: StringConstructor;
+        default: string;
+    };
+    restoreSelection: {
+        type: PropType<() => void>;
+        default: null;
+    };
+    handleClose: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    selectedText: {
+        type: StringConstructor;
+        default: string;
+    };
+    target: {
+        type: PropType<SelectionTarget | null>;
+        default: null;
+    };
+    doc: {
+        type: PropType<AiWriterDocument | null>;
+        default: null;
+    };
+    apiKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    endpoint: {
+        type: StringConstructor;
+        default: string;
+    };
+    restoreSelection: {
+        type: PropType<() => void>;
+        default: null;
+    };
+    handleClose: {
+        type: PropType<() => void>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    target: SelectionTarget | null;
+    doc: AiWriterDocument | null;
     selectedText: string;
-    restoreSelection: Function;
-    endpoint: string;
+    restoreSelection: () => void;
     apiKey: string;
-    handleClose: Function;
-    $props: {
-        readonly target?: Record<string, any> | undefined;
-        readonly doc?: Record<string, any> | undefined;
-        readonly selectedText?: string | undefined;
-        readonly restoreSelection?: Function | undefined;
-        readonly endpoint?: string | undefined;
-        readonly apiKey?: string | undefined;
-        readonly handleClose?: Function | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    endpoint: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     textareaRef: HTMLTextAreaElement;
 }, HTMLFormElement>;
 export default _default;

package/dist/superdoc/src/internal/toolbar/built-in/AlignmentButtons.vue.d.ts

@@ -1,6 +1,8 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     alignmentButtonsRefs: HTMLDivElement[];
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/internal/toolbar/built-in/ButtonGroup.vue.d.ts

@@ -1,9 +1,89 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "command" | "item-clicked" | "dropdown-update-show", ...args: any[]) => void;
-    $props: {
-        readonly [x: string]: any;
+import { PropType } from 'vue';
+import { ToolbarItem, ToolbarItemOption as DropdownOption } from '../built-in-toolbar.js';
+import { ComboBoxCommand, ComboBoxItem } from './ToolbarComboBox.vue.js';
+export type ToolbarGroupItem = Pick<ToolbarItem, 'type' | 'id' | 'name' | 'active' | 'icon' | 'label' | 'hideLabel' | 'iconColor' | 'hasCaret' | 'splitButton' | 'disabled' | 'expand' | 'inlineTextInputVisible' | 'hasInlineTextInput' | 'style' | 'attributes' | 'nestedOptions' | 'isNarrow' | 'isWide' | 'tooltip' | 'argument' | 'command' | 'splitButtonCommand' | 'restoreEditorFocus' | 'dropdownStyles' | 'dropdownValueKey' | 'selectedValue'>;
+export interface ToolbarGroupCommand {
+    item: ToolbarGroupItem | ComboBoxItem;
+    argument?: unknown;
+    option?: DropdownOption | ComboBoxCommand['option'];
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    toolbarItems: {
+        type: PropType<ToolbarGroupItem[]>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    overflowItems: {
+        type: PropType<ToolbarGroupItem[]>;
+        default: () => never[];
+    };
+    /**
+     * The font-family to use for UI elements like dropdowns and tooltips.
+     * This ensures consistent typography across toolbar UI components.
+     * @type {string}
+     * @default 'Arial, Helvetica, sans-serif'
+     */
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+    position: {
+        type: StringConstructor;
+        default: string;
+    };
+    fromOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    compactSideGroups: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    command: (payload: ToolbarGroupCommand) => any;
+    "item-clicked": () => any;
+    "dropdown-update-show": (open: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    toolbarItems: {
+        type: PropType<ToolbarGroupItem[]>;
+        required: true;
+    };
+    overflowItems: {
+        type: PropType<ToolbarGroupItem[]>;
+        default: () => never[];
+    };
+    /**
+     * The font-family to use for UI elements like dropdowns and tooltips.
+     * This ensures consistent typography across toolbar UI components.
+     * @type {string}
+     * @default 'Arial, Helvetica, sans-serif'
+     */
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+    position: {
+        type: StringConstructor;
+        default: string;
+    };
+    fromOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    compactSideGroups: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onCommand?: ((payload: ToolbarGroupCommand) => any) | undefined;
+    "onItem-clicked"?: (() => any) | undefined;
+    "onDropdown-update-show"?: ((open: boolean) => any) | undefined;
+}>, {
+    position: string;
+    uiFontFamily: string;
+    overflowItems: ToolbarGroupItem[];
+    fromOverflow: boolean;
+    compactSideGroups: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     buttonGroupRef: HTMLDivElement;
     toolbarItemRefs: HTMLDivElement[];
 }, HTMLDivElement>;