superdoc 2.29.0-next.2 → 2.29.0-next.3

package/dist/superdoc/src/components/surfaces/FindReplaceSurface.vue.d.ts

@@ -1,19 +1,62 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    close: Function;
-    mode: string;
-    resolve: Function;
-    request: Record<string, any>;
+import { PropType } from 'vue';
+import { FindReplaceHandle, SurfaceComponentProps, SurfaceMode, SurfaceRequest } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    findReplace: {
+        type: PropType<FindReplaceHandle>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    findReplace: {
+        type: PropType<FindReplaceHandle>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    close: (reason?: unknown) => void;
+    mode: SurfaceMode;
+    resolve: (data?: unknown) => void;
+    request: SurfaceRequest;
     surfaceId: string;
-    findReplace: Record<string, any>;
-    $props: {
-        readonly close?: Function | undefined;
-        readonly mode?: string | undefined;
-        readonly resolve?: Function | undefined;
-        readonly request?: Record<string, any> | undefined;
-        readonly surfaceId?: string | undefined;
-        readonly findReplace?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     findInputRef: HTMLInputElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/surfaces/PasswordPromptSurface.vue.d.ts

@@ -1,17 +1,60 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    close: Function;
-    mode: string;
-    resolve: Function;
-    request: Record<string, any>;
+import { PropType } from 'vue';
+import { PasswordPromptHandle, SurfaceComponentProps, SurfaceMode, SurfaceRequest } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    passwordPrompt: {
+        type: PropType<PasswordPromptHandle>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        default: string;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        default: string;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        default: () => {};
+    };
+    resolve: {
+        type: PropType<SurfaceComponentProps["resolve"]>;
+        default: () => void;
+    };
+    close: {
+        type: PropType<SurfaceComponentProps["close"]>;
+        default: () => void;
+    };
+    passwordPrompt: {
+        type: PropType<PasswordPromptHandle>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    close: (reason?: unknown) => void;
+    mode: SurfaceMode;
+    resolve: (data?: unknown) => void;
+    request: SurfaceRequest;
     surfaceId: string;
-    passwordPrompt: Record<string, any>;
-    $props: {
-        readonly close?: Function | undefined;
-        readonly mode?: string | undefined;
-        readonly resolve?: Function | undefined;
-        readonly request?: Record<string, any> | undefined;
-        readonly surfaceId?: string | undefined;
-        readonly passwordPrompt?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/surfaces/SurfaceFloating.vue.d.ts

@@ -1,10 +1,18 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    rootEl: import('vue').Ref<null, null>;
-    surface: Record<string, any>;
-    $props: {
-        readonly surface?: Record<string, any> | undefined;
+import { PropType } from 'vue';
+import { ActiveSurface } from '../../core/surface-manager.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surface: {
+        type: PropType<ActiveSurface>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}>, {
+    rootEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surface: {
+        type: PropType<ActiveSurface>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     floatingRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/surfaces/SurfaceHost.vue.d.ts

@@ -1,16 +1,25 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    geometryTarget: Record<string, any>;
-    $props: {
-        readonly geometryTarget?: Record<string, any> | undefined;
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    geometryTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    geometryTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    geometryTarget: HTMLElement | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     hostRef: HTMLDivElement;
-    floatingRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
-        rootEl: import('vue').Ref<null, null>;
-        surface: Record<string, any>;
-        $props: {
-            readonly surface?: Record<string, any> | undefined;
+    floatingRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        surface: {
+            type: PropType<import('../../core/surface-manager.js').ActiveSurface>;
+            required: true;
         };
+    }>> & Readonly<{}>, {
+        rootEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         floatingRef: HTMLDivElement;
     }, HTMLDivElement, import('vue').ComponentProvideOptions, {
@@ -20,12 +29,13 @@ declare const _default: import('vue').DefineComponent<{}, {
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<{}> & Readonly<{}>, {
-        rootEl: import('vue').Ref<null, null>;
-        surface: Record<string, any>;
-        $props: {
-            readonly surface?: Record<string, any> | undefined;
+    }, Readonly<import('vue').ExtractPropTypes<{
+        surface: {
+            type: PropType<import('../../core/surface-manager.js').ActiveSurface>;
+            required: true;
         };
+    }>> & Readonly<{}>, {
+        rootEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     }, {}, {}, {}, {}> | null;
 }, any>;
 export default _default;

package/dist/superdoc/src/core/SuperDoc.d.ts

@@ -103,12 +103,6 @@ interface SuperDocEventMap {
     'source:complete': [];
     'source:signals-complete': [];
 }
-/**
- * SuperDoc class
- * Expects a config object
- *
- * @class
- */
 export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
     #private;
     static allowedTypes: ("application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/pdf")[];
@@ -372,6 +366,7 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * @returns The attached room and document once the collaborative runtime is ready
      */
     upgradeToCollaboration(options: UpgradeToCollaborationOptions): Promise<UpgradeToCollaborationResult>;
+    setUser(user: User): Promise<void>;
     /**
      * Add a user to the shared users list. Requires the instance to be
      * ready; pre-ready mutations would be silently overwritten by the

package/dist/superdoc/src/core/editor-runtime/index.d.ts

@@ -1 +1 @@
-export type { EditorRuntimeKind, EditorRuntimeId, EditorRuntimeDocumentMode, EditorRuntimeState, EditorRuntime, EditorRuntimeSnapshot, EditorRuntimeCapabilities, RuntimeLifecycleCapabilities, RuntimeSelectionCapabilities, RuntimeCommandCapabilities, RuntimeFindReplaceCapabilities, RuntimeAiCapabilities, RuntimeCommentCapabilities, RuntimeTrackedChangeCapabilities, RuntimeToolbarCapabilities, RuntimeLayoutCapabilities, RuntimeZoomCapabilities, RuntimeNavigationCapabilities, RuntimePersistenceCapabilities, EditorRuntimeCommand, EditorRuntimeCommandKind, EditorRuntimeCommandResult, EditorRuntimeRejectionCode, EditorRuntimeNoopReason, EditorRuntimeSelectionSnapshot, EditorRuntimeFindSessionSnapshot, EditorRuntimeToolbarState, EditorRuntimeLayoutSnapshot, EditorRuntimePositionToken, EditorRuntimeFocusOptions, EditorRuntimeSaveOptions, EditorRuntimeExportOptions, EditorRuntimeNavigationTarget, EditorRuntimeEvent, EditorRuntimeListener, EditorRuntimeUnsubscribe, RuntimeJsonPrimitive, RuntimeJsonValue, RuntimeJsonObject, } from './types.js';
+export type { EditorRuntimeKind, EditorRuntimeId, EditorRuntimeDocumentMode, EditorRuntimeUser, EditorRuntimeState, EditorRuntime, EditorRuntimeSnapshot, EditorRuntimeCapabilities, RuntimeLifecycleCapabilities, RuntimeSelectionCapabilities, RuntimeCommandCapabilities, RuntimeFindReplaceCapabilities, RuntimeAiCapabilities, RuntimeCommentCapabilities, RuntimeTrackedChangeCapabilities, RuntimeToolbarCapabilities, RuntimeLayoutCapabilities, RuntimeZoomCapabilities, RuntimeNavigationCapabilities, RuntimePersistenceCapabilities, EditorRuntimeCommand, EditorRuntimeCommandKind, EditorRuntimeCommandResult, EditorRuntimeRejectionCode, EditorRuntimeNoopReason, EditorRuntimeSelectionSnapshot, EditorRuntimeFindSessionSnapshot, EditorRuntimeToolbarState, EditorRuntimeLayoutSnapshot, EditorRuntimePositionToken, EditorRuntimeFocusOptions, EditorRuntimeSaveOptions, EditorRuntimeExportOptions, EditorRuntimeNavigationTarget, EditorRuntimeEvent, EditorRuntimeListener, EditorRuntimeUnsubscribe, RuntimeJsonPrimitive, RuntimeJsonValue, RuntimeJsonObject, } from './types.js';

package/dist/superdoc/src/core/editor-runtime/types.d.ts

@@ -376,6 +376,12 @@ export type EditorRuntimeUnsubscribe = () => void;
  * synchronous so they can back existing synchronous shell APIs and Vue
  * computeds without forcing them async in current implementation.
  */
+export interface EditorRuntimeUser {
+    name: string;
+    id?: string;
+    email?: string;
+    initials?: string;
+}
 export interface EditorRuntime {
     readonly id: EditorRuntimeId;
     readonly kind: EditorRuntimeKind;
@@ -386,6 +392,7 @@ export interface EditorRuntime {
     getSnapshot(): EditorRuntimeSnapshot;
     setDocumentMode(mode: EditorRuntimeDocumentMode): void;
     getDocumentMode(): EditorRuntimeDocumentMode;
+    setUser?(user: EditorRuntimeUser): Promise<void>;
     setTrackedChangesRenderOptions(options?: {
         mode?: 'review' | 'original' | 'final' | 'off';
         enabled?: boolean;

package/dist/superdoc/src/core/editor-runtime/v2/v2-editor-runtime-adapter.d.ts

@@ -1,4 +1,4 @@
-import { EditorRuntime, EditorRuntimeDocumentMode, EditorRuntimeId, EditorRuntimeState } from '../index.js';
+import { EditorRuntime, EditorRuntimeDocumentMode, EditorRuntimeUser, EditorRuntimeId, EditorRuntimeState } from '../index.js';
 import { resolveV2DocxExportOptions } from '../../helpers/resolve-docx-export.js';
 type HostLifecycleState = EditorRuntimeState | 'ready';
 type HostCommandKind = 'text.insert' | 'text.replace' | 'text.deleteBackward' | 'text.deleteForward' | 'text.pastePlain' | 'history.undo' | 'history.redo' | 'structural.enter' | 'structural.listIndent' | 'structural.listOutdent' | string;
@@ -161,6 +161,7 @@ interface ModeAwareHostLike {
     subscribe(listener: (snapshot: HostSnapshotLike) => void): () => void;
     getDocumentMode(): EditorRuntimeDocumentMode;
     setDocumentMode(mode: EditorRuntimeDocumentMode): void;
+    setUser?(user: EditorRuntimeUser): Promise<void>;
     setTrackedChangesRenderOptions(options?: {
         mode?: 'review' | 'original' | 'final' | 'off';
         enabled?: boolean;

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

@@ -1,3 +1,11 @@
+import { default as commentIconSvg } from '../../../shared/common/icons/comment-solid.svg?raw';
+import { default as caretDownIconSvg } from '../../../shared/common/icons/caret-down-solid.svg?raw';
+import { default as userCheckIconSvg } from '../../../shared/common/icons/user-check-solid.svg?raw';
+import { default as usersIconSvg } from '../../../shared/common/icons/users-solid.svg?raw';
+import { default as checkIconSvg } from '../../../shared/common/icons/check-solid.svg?raw';
+import { default as xmarkIconSvg } from '../../../shared/common/icons/xmark-solid.svg?raw';
+import { default as ellipsisVerticalSvg } from '../../../shared/common/icons/ellipsis-vertical-solid.svg?raw';
+import { default as rotateLeftSvg } from '../../../shared/common/icons/rotate-left-solid.svg?raw';
 export namespace superdocIcons {
     export { commentIconSvg as comment };
     export { caretDownIconSvg as caretDown };

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>;
-    restoreSelection: Function;
+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;
+    restoreSelection: () => void;
     selectedText: string;
     endpoint: string;
     apiKey: string;
-    handleClose: Function;
-    $props: {
-        readonly target?: Record<string, any> | undefined;
-        readonly doc?: Record<string, any> | undefined;
-        readonly restoreSelection?: Function | undefined;
-        readonly selectedText?: string | 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, {
+}, {}, {}, {}, 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,109 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "command" | "item-clicked" | "dropdown-update-show", ...args: any[]) => void;
-    $props: {
-        readonly [x: string]: any;
+import { PropType, Ref, StyleValue } from 'vue';
+import { default as ToolbarButton } from './ToolbarButton.vue.js';
+import { default as ToolbarDropdown } from './ToolbarDropdown.vue.js';
+import { default as FontFamilyCombobox } from './FontFamilyCombobox.vue';
+type ButtonItem = InstanceType<typeof ToolbarButton>['$props']['toolbarItem'];
+type ComboBoxProps = InstanceType<typeof FontFamilyCombobox>['$props'];
+type ComboBoxItem = ComboBoxProps['item'];
+type ComboBoxCommand = Parameters<NonNullable<ComboBoxProps['onCommand']>>[0];
+type DropdownOption = NonNullable<InstanceType<typeof ToolbarDropdown>['$props']['options']>[number];
+export interface ToolbarGroupItem extends ButtonItem {
+    type: string;
+    id: Ref<string>;
+    isNarrow: Ref<boolean | undefined>;
+    isWide: Ref<boolean | undefined>;
+    tooltip: Ref<string | undefined>;
+    argument: Ref<unknown>;
+    command?: unknown;
+    splitButtonCommand?: unknown;
+    restoreEditorFocus: boolean;
+    dropdownStyles: Ref<StyleValue | undefined>;
+    dropdownValueKey: Ref<string | undefined>;
+    selectedValue: Ref<string | number | null | undefined>;
+    nestedOptions: Ref<DropdownOption[]>;
+}
+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>;

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

@@ -1,10 +1,24 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-    options?: unknown[] | undefined;
-    $props: {
-        readonly options?: unknown[] | undefined;
+import { PropType } from 'vue';
+interface DocumentModeOption {
+    label: string;
+    value: string;
+    icon: string;
+    description: string;
+    disabled?: boolean;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<DocumentModeOption[]>;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<DocumentModeOption[]>;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     documentModeRefs: HTMLDivElement[];
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,14 +1,46 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "select" | "clickoutside", ...args: any[]) => void;
-    icons: unknown[];
+import { PropType, Ref } from 'vue';
+import { ColorOption } from './IconGridRow.vue.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    icons: {
+        type: PropType<ColorOption[][]>;
+        required: true;
+    };
+    customIcons: {
+        type: PropType<ColorOption[][]>;
+        required: false;
+    };
+    activeColor: {
+        type: PropType<Ref<string | null | undefined>>;
+        required: false;
+    };
+    hasNoneIcon: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+    clickoutside: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    icons: {
+        type: PropType<ColorOption[][]>;
+        required: true;
+    };
+    customIcons: {
+        type: PropType<ColorOption[][]>;
+        required: false;
+    };
+    activeColor: {
+        type: PropType<Ref<string | null | undefined>>;
+        required: false;
+    };
+    hasNoneIcon: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+    onClickoutside?: ((...args: any[]) => any) | undefined;
+}>, {
     hasNoneIcon: boolean;
-    activeColor?: Record<string, any> | undefined;
-    customIcons?: unknown[] | undefined;
-    $props: {
-        readonly icons?: unknown[] | undefined;
-        readonly hasNoneIcon?: boolean | undefined;
-        readonly activeColor?: Record<string, any> | undefined;
-        readonly customIcons?: unknown[] | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;