superdoc 2.29.0-next.2 → 2.29.0-next.9

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 @@
-/**
- * @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/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/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} | null} [payload]
- * @returns {number}
  */
-export function getV2DiagnosticGeneration(payload?: {
+export declare function getV2DiagnosticGeneration(payload?: {
     generation?: unknown;
 } | 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>;
-    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;
     selectedText: string;
-    endpoint: string;
+    restoreSelection: () => void;
     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, {
+    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>;

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/FontFamilyCombobox.vue.d.ts

@@ -1,10 +1,34 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "command" | "item-clicked" | "tab-out" | "editor-handoff", ...args: any[]) => void;
-    item: Record<string, any>;
-    uiFontFamily: string;
-    $props: {
-        readonly item?: Record<string, any> | undefined;
-        readonly uiFontFamily?: string | undefined;
+import { PropType } from 'vue';
+import { ComboBoxCommand, ComboBoxItem, ComboBoxTabOut } from './ToolbarComboBox.vue.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
+    };
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    command: (payload: ComboBoxCommand) => any;
+    "item-clicked": () => any;
+    "tab-out": (event: ComboBoxTabOut) => any;
+    "editor-handoff": () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onCommand?: ((payload: ComboBoxCommand) => any) | undefined;
+    "onItem-clicked"?: (() => any) | undefined;
+    "onTab-out"?: ((event: ComboBoxTabOut) => any) | undefined;
+    "onEditor-handoff"?: (() => any) | undefined;
+}>, {
+    uiFontFamily: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

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

@@ -1,10 +1,34 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "command" | "item-clicked" | "tab-out" | "editor-handoff", ...args: any[]) => void;
-    item: Record<string, any>;
-    uiFontFamily: string;
-    $props: {
-        readonly item?: Record<string, any> | undefined;
-        readonly uiFontFamily?: string | undefined;
+import { PropType } from 'vue';
+import { ComboBoxCommand, ComboBoxItem, ComboBoxTabOut } from './ToolbarComboBox.vue.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
+    };
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    command: (payload: ComboBoxCommand) => any;
+    "item-clicked": () => any;
+    "tab-out": (event: ComboBoxTabOut) => any;
+    "editor-handoff": () => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ComboBoxItem>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    uiFontFamily: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onCommand?: ((payload: ComboBoxCommand) => any) | undefined;
+    "onItem-clicked"?: (() => any) | undefined;
+    "onTab-out"?: ((event: ComboBoxTabOut) => any) | undefined;
+    "onEditor-handoff"?: (() => any) | undefined;
+}>, {
+    uiFontFamily: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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;