superdoc 2.29.0-next.1 → 2.29.0-next.3

package/dist/superdoc/src/components/CommentsLayer/CommentHeader.vue.d.ts

@@ -1,26 +1,110 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "reject" | "resolve" | "reopen" | "overflow-select", ...args: any[]) => void;
-    config: Record<string, any>;
+import { PropType } from 'vue';
+import { CommentModel } from './use-comment.js';
+type HeaderConfig = {
+    readOnly?: boolean;
+    allowResolve?: boolean;
+};
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    timestamp: {
+        type: NumberConstructor;
+        required: false;
+    };
+    config: {
+        type: PropType<HeaderConfig>;
+        required: true;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+    isPendingInput: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    isActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    resolveDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    rejectDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenSupported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    writeDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reject: (...args: any[]) => void;
+    resolve: (...args: any[]) => void;
+    reopen: (...args: any[]) => void;
+    "overflow-select": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    timestamp: {
+        type: NumberConstructor;
+        required: false;
+    };
+    config: {
+        type: PropType<HeaderConfig>;
+        required: true;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+    isPendingInput: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    isActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    resolveDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    rejectDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    reopenSupported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    writeDisabledReason: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    onReject?: ((...args: any[]) => any) | undefined;
+    onResolve?: ((...args: any[]) => any) | undefined;
+    onReopen?: ((...args: any[]) => any) | undefined;
+    "onOverflow-select"?: ((...args: any[]) => any) | undefined;
+}>, {
     isActive: boolean;
     isPendingInput: boolean;
-    resolveDisabledReason: string;
-    rejectDisabledReason: string;
-    reopenDisabledReason: string;
+    resolveDisabledReason: string | null;
+    rejectDisabledReason: string | null;
+    reopenDisabledReason: string | null;
     reopenSupported: boolean;
-    writeDisabledReason: string;
-    comment?: Record<string, any> | undefined;
-    timestamp?: number | undefined;
-    $props: {
-        readonly config?: Record<string, any> | undefined;
-        readonly isActive?: boolean | undefined;
-        readonly isPendingInput?: boolean | undefined;
-        readonly resolveDisabledReason?: string | undefined;
-        readonly rejectDisabledReason?: string | undefined;
-        readonly reopenDisabledReason?: string | undefined;
-        readonly reopenSupported?: boolean | undefined;
-        readonly writeDisabledReason?: string | undefined;
-        readonly comment?: Record<string, any> | undefined;
-        readonly timestamp?: number | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    writeDisabledReason: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/CommentInput.vue.d.ts

@@ -1,19 +1,79 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    focus: (options: any) => void;
-    $emit: (event: "focus", ...args: any[]) => void;
-    config: Record<string, any>;
+import { PropType } from 'vue';
+import { User } from '../../core/types/index.js';
+import { CommentModel } from './use-comment.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    users: {
+        type: PropType<readonly (User & {
+            access?: string | {
+                role?: string;
+            } | null;
+        })[]>;
+        required: false;
+        default: () => never[];
+    };
+    config: {
+        type: PropType<{
+            readOnly?: boolean;
+            allowResolve?: boolean;
+        }>;
+        required: true;
+    };
+    isFocused: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    includeHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+}>, {
+    focus: (options?: FocusOptions) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    users: {
+        type: PropType<readonly (User & {
+            access?: string | {
+                role?: string;
+            } | null;
+        })[]>;
+        required: false;
+        default: () => never[];
+    };
+    config: {
+        type: PropType<{
+            readOnly?: boolean;
+            allowResolve?: boolean;
+        }>;
+        required: true;
+    };
+    isFocused: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    includeHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    comment: {
+        type: PropType<CommentModel>;
+        required: true;
+    };
+}>> & Readonly<{
+    onFocus?: ((...args: any[]) => any) | undefined;
+}>, {
     isFocused: boolean;
-    users: unknown[];
+    users: readonly (User & {
+        access?: string | {
+            role?: string;
+        } | null;
+    })[];
     includeHeader: boolean;
-    comment?: Record<string, any> | undefined;
-    $props: {
-        readonly config?: Record<string, any> | undefined;
-        readonly isFocused?: boolean | undefined;
-        readonly users?: unknown[] | undefined;
-        readonly includeHeader?: boolean | undefined;
-        readonly comment?: 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, {
     inputRef: HTMLTextAreaElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/CommentsDropdown.vue.d.ts

@@ -1,23 +1,12 @@
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
-export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & (new () => {
-    $slots: S;
-});
-declare const __VLS_component: import('vue').DefineComponent<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-    options: unknown[];
-    disabled: boolean;
-    contentStyle: Record<string, any>;
-    $props: {
-        readonly options?: unknown[] | undefined;
-        readonly disabled?: boolean | undefined;
-        readonly contentStyle?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    triggerRef: HTMLDivElement;
-    menuRef: HTMLDivElement;
-}, HTMLDivElement>;
-type __VLS_TemplateResult = {
+import { CSSProperties, PropType, VNodeChild } from 'vue';
+type CommentsDropdownOption = {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    iconString?: string;
+    icon?: VNodeChild | ((option: CommentsDropdownOption) => VNodeChild);
+};
+declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
@@ -28,3 +17,49 @@ type __VLS_TemplateResult = {
     };
     rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<readonly CommentsDropdownOption[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: {
+        type: PropType<readonly CommentsDropdownOption[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentStyle: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    options: readonly CommentsDropdownOption[];
+    disabled: boolean;
+    contentStyle: CSSProperties;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    triggerRef: HTMLDivElement;
+    menuRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/superdoc/src/components/CommentsLayer/InternalDropdown.vue.d.ts

@@ -1,10 +1,26 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "select", ...args: any[]) => void;
-    isDisabled: boolean;
-    state?: string | undefined;
-    $props: {
-        readonly isDisabled?: boolean | undefined;
-        readonly state?: string | undefined;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    state: {
+        type: StringConstructor;
+        required: false;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    state: {
+        type: StringConstructor;
+        required: false;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/PdfCommentsLayer.vue.d.ts

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

package/dist/superdoc/src/components/CommentsLayer/commentsList/ReviewDirectoryListItem.vue.d.ts

@@ -1,16 +1,64 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "navigate" | "focus-item", ...args: any[]) => void;
-    index: number;
-    total: number;
-    item: Record<string, any>;
-    tabIndex: number;
-    $props: {
-        readonly index?: number | undefined;
-        readonly total?: number | undefined;
-        readonly item?: Record<string, any> | undefined;
-        readonly tabIndex?: number | undefined;
+import { PropType } from 'vue';
+import { CommentModel } from '../use-comment.js';
+export type PositionEntry = {
+    pageIndex?: number | null;
+    bounds?: {
+        top?: number;
+        bottom?: number;
+    } | null;
+};
+export type ReviewDirectoryItem = {
+    id: string | undefined;
+    comment: CommentModel;
+    floatingInstanceId: string | null;
+    floatingPageIndex: number | null | undefined;
+    floatingPositionEntry: PositionEntry | null;
+    isFloatingInstanceActive: boolean | undefined;
+    threadComments: CommentModel[];
+};
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ReviewDirectoryItem>;
+        required: true;
+    };
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    navigate: (...args: any[]) => void;
+    "focus-item": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        type: PropType<ReviewDirectoryItem>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    index: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onNavigate?: ((...args: any[]) => any) | undefined;
+    "onFocus-item"?: ((...args: any[]) => any) | undefined;
+}>, {
+    tabIndex: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     shell: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/commentsList/commentsList.vue.d.ts

@@ -1,11 +1,25 @@
-declare const _default: import('vue').DefineComponent<{}, {
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    showMainComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showResolvedComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    showMainComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showResolvedComments: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
     showMainComments: boolean;
     showResolvedComments: boolean;
-    $props: {
-        readonly showMainComments?: boolean | undefined;
-        readonly showResolvedComments?: boolean | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     listRoot: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/components/CommentsLayer/use-comment.d.ts

@@ -326,4 +326,5 @@ export default function useComment(params: UseCommentParams): {
     };
     updateIdentityValues: (updates?: CommentIdentity) => void;
 };
+export type CommentModel = ReturnType<typeof useComment>;
 export {};

package/dist/superdoc/src/components/general/Avatar.vue.d.ts

@@ -1,7 +1,14 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    user: Record<string, any>;
-    $props: {
-        readonly user?: Record<string, any> | undefined;
+import { PropType } from 'vue';
+import { User } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    user: {
+        type: PropType<User>;
+        required: true;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    user: {
+        type: PropType<User>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

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;