import { AllowedComponentProps } from 'vue';
import { Attrs } from 'vue';
import { ComponentCustomProperties } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentInternalInstance } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { DebuggerEvent } from 'vue';
import { DefineComponent } from 'vue';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { nextTick } from 'vue';
import { OnCleanup } from '@vue/reactivity';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { ShallowRef } from 'vue';
import { Slot } from 'vue';
import { VNodeProps } from 'vue';
import { WatchOptions } from 'vue';
import { WatchStopHandle } from 'vue';

/** Test seam: send whatever is pending now, without waiting out the debounce. */
export declare function __flushViewPrefs(): void;

/** Test seam — the console line is once per value per page, so a suite that
 *  asserts on it has to be able to start over. Not used by the app. */
export declare function __resetUiProfileWarnings(): void;

/** Test seam: drop the transport and the state, so one suite cannot leak a
 *  document into the next. Not used by the app. */
export declare function __resetViewPrefs(): void;

declare const __VLS_component: DefineComponent<__VLS_Props, {
reload: () => Promise<void>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (err: {
message: string;
context?: unknown;
}) => any;
refresh: () => any;
"share-created": (payload: {
path: string;
url: string;
pin: string | null;
}) => any;
navigate: (p: {
path: string;
}) => any;
"file-opened": (file: {
path: string;
basename: string;
}) => any;
"upload-progress": (p: {
uploadId: string;
percent: number;
done: boolean;
}) => any;
"selection-change": (items: {
path: string;
basename: string;
type: "file" | "dir";
}[]) => any;
}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
onError?: ((err: {
message: string;
context?: unknown;
}) => any) | undefined;
onRefresh?: (() => any) | undefined;
"onShare-created"?: ((payload: {
path: string;
url: string;
pin: string | null;
}) => any) | undefined;
onNavigate?: ((p: {
path: string;
}) => any) | undefined;
"onFile-opened"?: ((file: {
path: string;
basename: string;
}) => any) | undefined;
"onUpload-progress"?: ((p: {
uploadId: string;
percent: number;
done: boolean;
}) => any) | undefined;
"onSelection-change"?: ((items: {
path: string;
basename: string;
type: "file" | "dir";
}[]) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
rootEl: HTMLDivElement;
toolbarRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly viewMode: ViewMode;
readonly searchQuery: string;
readonly trashActive: boolean;
readonly actions: ContextAction[];
readonly selectionMode?: SelectionMode_2 | undefined;
readonly selectionCount?: number | undefined;
readonly selectionPane?: string | undefined;
readonly pasteEnabled?: boolean | undefined;
readonly convertEnabled?: boolean | undefined;
readonly canGoUp?: boolean | undefined;
readonly atVirtualRoot?: boolean | undefined;
readonly canWrite?: boolean | undefined;
readonly locale: LocaleCode;
readonly narrow?: boolean | undefined;
readonly theme?: ThemeMode | undefined;
readonly inspectorOpen?: boolean | undefined;
readonly navOpen?: boolean | undefined;
readonly navEnabled?: boolean | undefined;
readonly viewModes?: ViewMode[] | undefined;
readonly scopeLabel?: string | undefined;
readonly brandName?: string | undefined;
readonly brandMarkUrl?: string | undefined;
readonly searchEscalates?: boolean | undefined;
readonly onAction?: ((key: string) => any) | undefined;
readonly onUpload?: (() => any) | undefined;
readonly "onGo-up"?: (() => any) | undefined;
readonly "onNew-folder"?: (() => any) | undefined;
readonly onRefresh?: (() => any) | undefined;
readonly "onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
readonly "onUpdate:searchQuery"?: ((v: string) => any) | undefined;
readonly "onOpen-advanced-search"?: ((v: string) => any) | undefined;
readonly "onOpen-recents"?: (() => any) | undefined;
readonly "onUpdate:density"?: ((v: Density) => any) | undefined;
readonly "onToggle-inspector"?: (() => any) | undefined;
readonly "onToggle-nav"?: (() => any) | undefined;
readonly "onOpen-theme"?: (() => any) | undefined;
readonly "onOpen-shortcut-settings"?: (() => any) | undefined;
readonly "onOpen-timezone"?: (() => any) | undefined;
readonly "onOpen-palette"?: ((query: string) => any) | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: Attrs;
$refs: {
[x: string]: unknown;
} & {
rootEl: HTMLDivElement;
searchEl: HTMLInputElement;
moreBtnEl: HTMLButtonElement;
moreRef: CreateComponentPublicInstanceWithMixins<Readonly<{
locale: LocaleCode;
actions: ContextAction[];
theme?: ThemeMode;
sheet?: boolean;
}> & Readonly<{
onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
}>, {
show: (ev: {
clientX: number;
clientY: number;
}, nodes: FileNode[]) => Promise<void>;
hide: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (action: ContextAction, target: FileNode[]) => any;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
sheetEl: HTMLDivElement;
menuEl: HTMLDivElement;
}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
locale: LocaleCode;
actions: ContextAction[];
theme?: ThemeMode;
sheet?: boolean;
}> & Readonly<{
onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
}>, {
show: (ev: {
clientX: number;
clientY: number;
}, nodes: FileNode[]) => Promise<void>;
hide: () => void;
}, {}, {}, {}, {}> | null;
selBarEl: HTMLDivElement;
selMoreBtnEl: HTMLButtonElement;
measureEl: HTMLDivElement;
selMoreRef: CreateComponentPublicInstanceWithMixins<Readonly<{
locale: LocaleCode;
actions: ContextAction[];
theme?: ThemeMode;
sheet?: boolean;
}> & Readonly<{
onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
}>, {
show: (ev: {
clientX: number;
clientY: number;
}, nodes: FileNode[]) => Promise<void>;
hide: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (action: ContextAction, target: FileNode[]) => any;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
sheetEl: HTMLDivElement;
menuEl: HTMLDivElement;
}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
locale: LocaleCode;
actions: ContextAction[];
theme?: ThemeMode;
sheet?: boolean;
}> & Readonly<{
onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
}>, {
show: (ev: {
clientX: number;
clientY: number;
}, nodes: FileNode[]) => Promise<void>;
hide: () => void;
}, {}, {}, {}, {}> | null;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: ((event: "action", key: string) => void) & ((event: "upload") => void) & ((event: "go-up") => void) & ((event: "new-folder") => void) & ((event: "refresh") => void) & ((event: "update:viewMode", v: ViewMode) => void) & ((event: "update:searchQuery", v: string) => void) & ((event: "open-advanced-search", v: string) => void) & ((event: "open-recents") => void) & ((event: "update:density", v: Density) => void) & ((event: "toggle-inspector") => void) & ((event: "toggle-nav") => void) & ((event: "open-theme") => void) & ((event: "open-shortcut-settings") => void) & ((event: "open-timezone") => void) & ((event: "open-palette", query: string) => void);
$el: HTMLDivElement;
$options: ComponentOptionsBase<Readonly<{
viewMode: ViewMode;
searchQuery: string;
trashActive: boolean;
actions: ContextAction[];
selectionMode?: SelectionMode_2;
selectionCount?: number;
selectionPane?: string;
pasteEnabled?: boolean;
convertEnabled?: boolean;
canGoUp?: boolean;
atVirtualRoot?: boolean;
canWrite?: boolean;
locale: LocaleCode;
narrow?: boolean;
theme?: ThemeMode;
inspectorOpen?: boolean;
navOpen?: boolean;
navEnabled?: boolean;
viewModes?: ViewMode[];
scopeLabel?: string;
brandName?: string;
brandMarkUrl?: string;
searchEscalates?: boolean;
}> & Readonly<{
onAction?: ((key: string) => any) | undefined;
onUpload?: (() => any) | undefined;
"onGo-up"?: (() => any) | undefined;
"onNew-folder"?: (() => any) | undefined;
onRefresh?: (() => any) | undefined;
"onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
"onUpdate:searchQuery"?: ((v: string) => any) | undefined;
"onOpen-advanced-search"?: ((v: string) => any) | undefined;
"onOpen-recents"?: (() => any) | undefined;
"onUpdate:density"?: ((v: Density) => any) | undefined;
"onToggle-inspector"?: (() => any) | undefined;
"onToggle-nav"?: (() => any) | undefined;
"onOpen-theme"?: (() => any) | undefined;
"onOpen-shortcut-settings"?: (() => any) | undefined;
"onOpen-timezone"?: (() => any) | undefined;
"onOpen-palette"?: ((query: string) => any) | undefined;
}>, {
focusSearch: () => Promise<void>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
action: (key: string) => any;
upload: () => any;
"go-up": () => any;
"new-folder": () => any;
refresh: () => any;
"update:viewMode": (v: ViewMode) => any;
"update:searchQuery": (v: string) => any;
"open-advanced-search": (v: string) => any;
"open-recents": () => any;
"update:density": (v: Density) => any;
"toggle-inspector": () => any;
"toggle-nav": () => any;
"open-theme": () => any;
"open-shortcut-settings": () => any;
"open-timezone": () => any;
"open-palette": (query: string) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: typeof nextTick;
$watch<T extends string | ((
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: any) => any)>(source: T, cb: T extends (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: any) => infer R ? (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: [R, R, OnCleanup]) => any : (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{}> & Omit<Readonly<{
viewMode: ViewMode;
searchQuery: string;
trashActive: boolean;
actions: ContextAction[];
selectionMode?: SelectionMode_2;
selectionCount?: number;
selectionPane?: string;
pasteEnabled?: boolean;
convertEnabled?: boolean;
canGoUp?: boolean;
atVirtualRoot?: boolean;
canWrite?: boolean;
locale: LocaleCode;
narrow?: boolean;
theme?: ThemeMode;
inspectorOpen?: boolean;
navOpen?: boolean;
navEnabled?: boolean;
viewModes?: ViewMode[];
scopeLabel?: string;
brandName?: string;
brandMarkUrl?: string;
searchEscalates?: boolean;
}> & Readonly<{
onAction?: ((key: string) => any) | undefined;
onUpload?: (() => any) | undefined;
"onGo-up"?: (() => any) | undefined;
"onNew-folder"?: (() => any) | undefined;
onRefresh?: (() => any) | undefined;
"onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
"onUpdate:searchQuery"?: ((v: string) => any) | undefined;
"onOpen-advanced-search"?: ((v: string) => any) | undefined;
"onOpen-recents"?: (() => any) | undefined;
"onUpdate:density"?: ((v: Density) => any) | undefined;
"onToggle-inspector"?: (() => any) | undefined;
"onToggle-nav"?: (() => any) | undefined;
"onOpen-theme"?: (() => any) | undefined;
"onOpen-shortcut-settings"?: (() => any) | undefined;
"onOpen-timezone"?: (() => any) | undefined;
"onOpen-palette"?: ((query: string) => any) | undefined;
}>, "focusSearch"> & {
focusSearch: () => Promise<void>;
} & {} & ComponentCustomProperties & {} & {
$slots: {
brand?(_: {}): any;
'header-actions'?(_: {}): any;
'header-actions'?(_: {}): any;
};
}) | null;
mainPaneRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
readonly paneId: PaneId;
readonly api: FileApi;
readonly locale: LocaleCode;
readonly theme?: ThemeMode | undefined;
readonly focused?: boolean | undefined;
readonly closable?: boolean | undefined;
readonly path: string;
readonly selfDriven?: boolean | undefined;
readonly qualify: (p: string) => string;
readonly toUser: (wire: string) => string;
readonly clamp: (p: string) => string;
readonly rootLabel?: string | undefined;
readonly rootPath?: string | undefined;
readonly floor?: string | undefined;
readonly multiRoot?: boolean | undefined;
readonly virtualRows?: (() => FileNode[]) | undefined;
readonly trashVisible?: boolean | undefined;
readonly navOffersTrash?: boolean | undefined;
readonly rows?: FileNode[] | undefined;
readonly loading?: boolean | undefined;
readonly error?: string | undefined;
readonly order?: ListingOrder | undefined;
readonly viewMode: ViewMode;
readonly viewModes?: ViewMode[] | undefined;
readonly showCrumbs?: boolean | undefined;
readonly showFilterBar?: boolean | undefined;
readonly filterMode?: "full" | "find" | undefined;
readonly findLabel?: string | undefined;
readonly showViewSwitcher?: boolean | undefined;
readonly crumbSubfolders?: {
label: string;
adapterPath: string;
}[] | undefined;
readonly folderKey?: string | undefined;
readonly showParentPath?: boolean | undefined;
readonly clipped?: Set<string> | undefined;
readonly extraFilters?: (DriveFilters | null) | undefined;
readonly canWrite?: boolean | undefined;
readonly canPaste?: boolean | undefined;
readonly selected: Set<string>;
readonly filters: DriveFilters;
readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
readonly starredIds?: Set<number> | undefined;
readonly starEnabled?: boolean | undefined;
readonly apiBase?: string | undefined;
readonly authHeaders?: (() => Record<string, string> | Promise<Record<string, string>>) | undefined;
readonly authCredentials?: RequestCredentials | undefined;
readonly e2eActive?: boolean | undefined;
readonly bodyOverride?: boolean | undefined;
readonly openTrigger?: "single" | "double" | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: Attrs;
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: string, ...args: any[]) => void;
$el: HTMLElement;
$options: ComponentOptionsBase<Readonly<{
paneId: PaneId;
api: FileApi;
locale: LocaleCode;
theme?: ThemeMode;
focused?: boolean;
closable?: boolean;
path: string;
selfDriven?: boolean;
qualify: (p: string) => string;
toUser: (wire: string) => string;
clamp: (p: string) => string;
rootLabel?: string;
rootPath?: string;
floor?: string;
multiRoot?: boolean;
virtualRows?: () => FileNode[];
trashVisible?: boolean;
navOffersTrash?: boolean;
rows?: FileNode[];
loading?: boolean;
error?: string;
order?: ListingOrder;
viewMode: ViewMode;
viewModes?: ViewMode[];
showCrumbs?: boolean;
showFilterBar?: boolean;
filterMode?: "full" | "find";
findLabel?: string;
showViewSwitcher?: boolean;
crumbSubfolders?: {
label: string;
adapterPath: string;
}[];
folderKey?: string;
showParentPath?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starEnabled?: boolean;
apiBase?: string;
authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
authCredentials?: RequestCredentials;
e2eActive?: boolean;
bodyOverride?: boolean;
openTrigger?: "single" | "double";
}> & Readonly<{
[x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, {
reload: () => Promise<void>;
goUp: () => void;
getPath: () => string;
visibleNodes: () => FileNode[];
loadFolder: (target?: string) => Promise<void>;
rowCount: () => number;
rowPaths: () => string[];
dirPerm: () => string;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
[x: string]: any;
}, string, {
trashVisible: boolean;
showCrumbs: boolean;
showFilterBar: boolean;
showViewSwitcher: boolean;
openTrigger: "single" | "double";
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: typeof nextTick;
$watch<T extends string | ((
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: any) => any)>(source: T, cb: T extends (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: any) => infer R ? (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: [R, R, OnCleanup]) => any : (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
trashVisible: boolean;
showCrumbs: boolean;
showFilterBar: boolean;
showViewSwitcher: boolean;
openTrigger: "single" | "double";
}> & Omit<Readonly<{
paneId: PaneId;
api: FileApi;
locale: LocaleCode;
theme?: ThemeMode;
focused?: boolean;
closable?: boolean;
path: string;
selfDriven?: boolean;
qualify: (p: string) => string;
toUser: (wire: string) => string;
clamp: (p: string) => string;
rootLabel?: string;
rootPath?: string;
floor?: string;
multiRoot?: boolean;
virtualRows?: () => FileNode[];
trashVisible?: boolean;
navOffersTrash?: boolean;
rows?: FileNode[];
loading?: boolean;
error?: string;
order?: ListingOrder;
viewMode: ViewMode;
viewModes?: ViewMode[];
showCrumbs?: boolean;
showFilterBar?: boolean;
filterMode?: "full" | "find";
findLabel?: string;
showViewSwitcher?: boolean;
crumbSubfolders?: {
label: string;
adapterPath: string;
}[];
folderKey?: string;
showParentPath?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starEnabled?: boolean;
apiBase?: string;
authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
authCredentials?: RequestCredentials;
e2eActive?: boolean;
bodyOverride?: boolean;
openTrigger?: "single" | "double";
}> & Readonly<{
[x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, "reload" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowCount" | "rowPaths" | ("trashVisible" | "showCrumbs" | "showFilterBar" | "showViewSwitcher" | "openTrigger")> & {
reload: () => Promise<void>;
goUp: () => void;
getPath: () => string;
visibleNodes: () => FileNode[];
loadFolder: (target?: string) => Promise<void>;
rowCount: () => number;
rowPaths: () => string[];
dirPerm: () => string;
} & {} & ComponentCustomProperties & {} & {
$slots: {
heading?(_: {}): any;
banners?(_: {}): any;
body?(_: {}): any;
empty?(_: {}): any;
};
}) | null;
splitPaneRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
readonly paneId: PaneId;
readonly api: FileApi;
readonly locale: LocaleCode;
readonly theme?: ThemeMode | undefined;
readonly focused?: boolean | undefined;
readonly closable?: boolean | undefined;
readonly path: string;
readonly selfDriven?: boolean | undefined;
readonly qualify: (p: string) => string;
readonly toUser: (wire: string) => string;
readonly clamp: (p: string) => string;
readonly rootLabel?: string | undefined;
readonly rootPath?: string | undefined;
readonly floor?: string | undefined;
readonly multiRoot?: boolean | undefined;
readonly virtualRows?: (() => FileNode[]) | undefined;
readonly trashVisible?: boolean | undefined;
readonly navOffersTrash?: boolean | undefined;
readonly rows?: FileNode[] | undefined;
readonly loading?: boolean | undefined;
readonly error?: string | undefined;
readonly order?: ListingOrder | undefined;
readonly viewMode: ViewMode;
readonly viewModes?: ViewMode[] | undefined;
readonly showCrumbs?: boolean | undefined;
readonly showFilterBar?: boolean | undefined;
readonly filterMode?: "full" | "find" | undefined;
readonly findLabel?: string | undefined;
readonly showViewSwitcher?: boolean | undefined;
readonly crumbSubfolders?: {
label: string;
adapterPath: string;
}[] | undefined;
readonly folderKey?: string | undefined;
readonly showParentPath?: boolean | undefined;
readonly clipped?: Set<string> | undefined;
readonly extraFilters?: (DriveFilters | null) | undefined;
readonly canWrite?: boolean | undefined;
readonly canPaste?: boolean | undefined;
readonly selected: Set<string>;
readonly filters: DriveFilters;
readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
readonly starredIds?: Set<number> | undefined;
readonly starEnabled?: boolean | undefined;
readonly apiBase?: string | undefined;
readonly authHeaders?: (() => Record<string, string> | Promise<Record<string, string>>) | undefined;
readonly authCredentials?: RequestCredentials | undefined;
readonly e2eActive?: boolean | undefined;
readonly bodyOverride?: boolean | undefined;
readonly openTrigger?: "single" | "double" | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: Attrs;
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: string, ...args: any[]) => void;
$el: HTMLElement;
$options: ComponentOptionsBase<Readonly<{
paneId: PaneId;
api: FileApi;
locale: LocaleCode;
theme?: ThemeMode;
focused?: boolean;
closable?: boolean;
path: string;
selfDriven?: boolean;
qualify: (p: string) => string;
toUser: (wire: string) => string;
clamp: (p: string) => string;
rootLabel?: string;
rootPath?: string;
floor?: string;
multiRoot?: boolean;
virtualRows?: () => FileNode[];
trashVisible?: boolean;
navOffersTrash?: boolean;
rows?: FileNode[];
loading?: boolean;
error?: string;
order?: ListingOrder;
viewMode: ViewMode;
viewModes?: ViewMode[];
showCrumbs?: boolean;
showFilterBar?: boolean;
filterMode?: "full" | "find";
findLabel?: string;
showViewSwitcher?: boolean;
crumbSubfolders?: {
label: string;
adapterPath: string;
}[];
folderKey?: string;
showParentPath?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starEnabled?: boolean;
apiBase?: string;
authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
authCredentials?: RequestCredentials;
e2eActive?: boolean;
bodyOverride?: boolean;
openTrigger?: "single" | "double";
}> & Readonly<{
[x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, {
reload: () => Promise<void>;
goUp: () => void;
getPath: () => string;
visibleNodes: () => FileNode[];
loadFolder: (target?: string) => Promise<void>;
rowCount: () => number;
rowPaths: () => string[];
dirPerm: () => string;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
[x: string]: any;
}, string, {
trashVisible: boolean;
showCrumbs: boolean;
showFilterBar: boolean;
showViewSwitcher: boolean;
openTrigger: "single" | "double";
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: typeof nextTick;
$watch<T extends string | ((
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: any) => any)>(source: T, cb: T extends (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: any) => infer R ? (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: [R, R, OnCleanup]) => any : (
/**
* FileExplorer — the public Vue component, panel + PWA + standalone use.
*
* Orchestrates:
*   - Directory listing (useFileApi)
*   - Chunked multipart upload (useUploadChunked) + drag & drop
*   - Selection + keyboard shortcuts
*   - Context menu (Teleport-based) with per-target actions
*   - Modal flows: newFolder / rename / delete / share / preview
*   - Eager Monaco preload so the code-edit path is snappy
*
* All backend endpoints arrive via the `config` prop. Auth is bearer
* (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
* the difference.
*/
...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
trashVisible: boolean;
showCrumbs: boolean;
showFilterBar: boolean;
showViewSwitcher: boolean;
openTrigger: "single" | "double";
}> & Omit<Readonly<{
paneId: PaneId;
api: FileApi;
locale: LocaleCode;
theme?: ThemeMode;
focused?: boolean;
closable?: boolean;
path: string;
selfDriven?: boolean;
qualify: (p: string) => string;
toUser: (wire: string) => string;
clamp: (p: string) => string;
rootLabel?: string;
rootPath?: string;
floor?: string;
multiRoot?: boolean;
virtualRows?: () => FileNode[];
trashVisible?: boolean;
navOffersTrash?: boolean;
rows?: FileNode[];
loading?: boolean;
error?: string;
order?: ListingOrder;
viewMode: ViewMode;
viewModes?: ViewMode[];
showCrumbs?: boolean;
showFilterBar?: boolean;
filterMode?: "full" | "find";
findLabel?: string;
showViewSwitcher?: boolean;
crumbSubfolders?: {
label: string;
adapterPath: string;
}[];
folderKey?: string;
showParentPath?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starEnabled?: boolean;
apiBase?: string;
authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
authCredentials?: RequestCredentials;
e2eActive?: boolean;
bodyOverride?: boolean;
openTrigger?: "single" | "double";
}> & Readonly<{
[x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, "reload" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowCount" | "rowPaths" | ("trashVisible" | "showCrumbs" | "showFilterBar" | "showViewSwitcher" | "openTrigger")> & {
reload: () => Promise<void>;
goUp: () => void;
getPath: () => string;
visibleNodes: () => FileNode[];
loadFolder: (target?: string) => Promise<void>;
rowCount: () => number;
rowPaths: () => string[];
dirPerm: () => string;
} & {} & ComponentCustomProperties & {} & {
$slots: {
heading?(_: {}): any;
banners?(_: {}): any;
body?(_: {}): any;
empty?(_: {}): any;
};
}) | null;
ctxRef: CreateComponentPublicInstanceWithMixins<Readonly<{
locale: LocaleCode;
actions: ContextAction[];
theme?: ThemeMode;
sheet?: boolean;
}> & Readonly<{
onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
}>, {
show: (ev: {
clientX: number;
clientY: number;
}, nodes: FileNode[]) => Promise<void>;
hide: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (action: ContextAction, target: FileNode[]) => any;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
sheetEl: HTMLDivElement;
menuEl: HTMLDivElement;
}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
locale: LocaleCode;
actions: ContextAction[];
theme?: ThemeMode;
sheet?: boolean;
}> & Readonly<{
onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
}>, {
show: (ev: {
clientX: number;
clientY: number;
}, nodes: FileNode[]) => Promise<void>;
hide: () => void;
}, {}, {}, {}, {}> | null;
fileInputEl: HTMLInputElement;
}, HTMLDivElement>;

declare const __VLS_component_2: DefineComponent<__VLS_Props_15, {
reload: typeof reload;
goUp: typeof goUp;
getPath: typeof getPath;
visibleNodes: typeof visibleNodes;
loadFolder: typeof loadFolder;
rowCount: typeof rowCount;
rowPaths: typeof rowPaths;
dirPerm: typeof dirPerm;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
[x: string]: any;
}, string, PublicProps, Readonly<__VLS_Props_15> & Readonly<{
[x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
}>, {
trashVisible: boolean;
showCrumbs: boolean;
showFilterBar: boolean;
showViewSwitcher: boolean;
openTrigger: "single" | "double";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

declare type __VLS_Props = {
    config: ExplorerConfig;
};

declare type __VLS_Props_10 = {
    locale: LocaleCode;
    /** `''` = the default row; otherwise an IANA id. */
    modelValue: string;
    /** What `''` resolves to on this surface — the zone and the tier. */
    fallback: ResolvedTimeZone;
    disabled?: boolean;
    /** Id for the input, so the host's own `<label for>` names the control. */
    inputId?: string;
    /** Accessible name for the list (the host's visible label, usually). */
    label?: string;
    /** `data-testid` prefix: `-filter`, `-list`, `-opt-<zone|device>`. */
    testid?: string;
};

declare type __VLS_Props_11 = {
    open: boolean;
    locale: LocaleCode;
    theme?: 'light' | 'dark' | 'auto';
};

declare type __VLS_Props_12 = {
    open: boolean;
    locale: LocaleCode;
    file: FileNode | null;
    previewUrl: (path: string) => string;
    downloadUrl: (path: string) => string;
    onlyOfficeBase?: string | null;
    onlyOfficeConfigEndpoint?: string | null;
    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
    authCredentials?: RequestCredentials;
    drawioUrl?: string | null;
    pdfWorkerUrl?: string | null;
    viewerBaseUrl?: string | null;
    theme?: 'light' | 'dark' | 'auto';
    /** 1-based position of `file` in the host's file list. */
    index?: number;
    /** How many files that list holds. */
    total?: number;
    /** API origin for the star toggle. */
    apiBase?: string;
    /** Draw the share action (the host must listen to `@share`). */
    shareEnabled?: boolean;
};

declare type __VLS_Props_13 = {
    center: OperationsStore;
    locale: LocaleCode;
    narrow?: boolean;
};

declare type __VLS_Props_14 = {
    tabs: TabItem[];
    activeId: string;
    locale: LocaleCode;
    /** false → the split toggle is hidden (narrow embeds). */
    splitEnabled?: boolean;
    /** true → the split toggle renders pressed (active tab has a pane). */
    splitActive?: boolean;
    /**
     * gorunum:v5-panerow — the details (inspector) toggle lives in this row too.
     *
     * ⚠ Opt-in, and absent means NOT DRAWN rather than "closed": until the host
     * moves its own copy out of the breadcrumb row there would otherwise be two
     * of the same button on screen, which is the duplicate this wave removes.
     */
    inspectorEnabled?: boolean;
    /** true → the details toggle renders pressed (the panel is open). */
    inspectorOpen?: boolean;
    /**
     * gorunum:v5-panerow — hide the tabs themselves (and "+"), keeping the row.
     *
     * ⚠ True is not "no tabs exist", it is "this deployment does not offer
     * them": the `simple` profile drops tabs deliberately (#14 named them as
     * power-user chrome) but still needs this row, because the details toggle
     * lives in it. Without the flag the row could only be all-or-nothing, and
     * the ⓘ would have to keep a second home in the breadcrumb row for that one
     * profile — a control with two homes is how the two drift.
     *
     * ⚠⚠ Phrased as HIDE, not SHOW, and that is not taste. A prop declared
     * `showTabs?: boolean` compiles to a runtime Boolean prop, and Vue casts an
     * ABSENT Boolean prop to `false` — not to `undefined`. So `showTabs !== false`
     * read false for every host that passed nothing, and the strip rendered with
     * no tabs and no "+" at all. Measured in a real browser: `.fe-tabs__tab`
     * count went from 1 to 0 the moment the prop was added, in both themes at
     * both widths. Negative default = safe default.
     */
    hideTabs?: boolean;
};

declare type __VLS_Props_15 = {
    /** Which half this is. Also the `data-pane` hook every measurement uses. */
    paneId: PaneId;
    api: FileApi;
    locale: LocaleCode;
    /** Resolved theme — forwarded to the children whose popovers are teleported
     *  out of `.fe`, where the token scope no longer reaches them. */
    theme?: ThemeMode;
    /** This pane owns the keyboard. The accent line, and nothing else. */
    focused?: boolean;
    /** Offer the × (the split pane). */
    closable?: boolean;
    /** The pane's location, in the host's user-path form. With
     *  `selfDriven` it is the OPENING location and this pane moves on from
     *  there; otherwise it is the address, full stop. */
    path: string;
    /** true → this pane fetches its own folder (see difference 2 above). */
    selfDriven?: boolean;
    /** user path → wire `<adapter>://<rel>`. */
    qualify: (p: string) => string;
    /** wire → user path (multi-storage aware). */
    toUser: (wire: string) => string;
    /** rootFloor clamp — keeps the pane inside the confine. */
    clamp: (p: string) => string;
    /** Override for the storage crumb's label. ⚠ Optional, and normally
     *  omitted: the pane derives it from its OWN wire path (`paneAdapter`), so
     *  two panes sitting in two different storages each name their own. The
     *  old right-hand pane was handed the window's label and printed "/" for a
     *  folder called `thumbfix` — measured 2026-09-13, and the exact shape of
     *  bug a second implementation produces. */
    rootLabel?: string;
    /** The confine in WIRE form, for `Breadcrumb`'s own floor handling. */
    rootPath?: string;
    /** rootFloor in user-path form ('' when unconfined). */
    floor?: string;
    /** Multi-storage mode: '' is the virtual drives root (no fetch). */
    multiRoot?: boolean;
    /** Synthesized storage rows for the virtual drives root. */
    virtualRows?: () => FileNode[];
    /** Mirror the virtual `.trash` row at a storage root. Defaults on. */
    trashVisible?: boolean;
    /** The navigation panel is already offering Trash, so no pane draws the
     *  virtual row. Passed down rather than worked out here: the panel is a
     *  sibling of BOTH panes, and a pane that guessed would list a row the
     *  other one does not. */
    navOffersTrash?: boolean;
    rows?: FileNode[];
    loading?: boolean;
    error?: string;
    /** Where these rows got their order (`lib/sortOrder`). A ranked answer
     *  keeps the server's order and closes every sort control over it. */
    order?: ListingOrder;
    viewMode: ViewMode;
    viewModes?: ViewMode[];
    /** Draw the address row. Off for a host that supplies its own heading. */
    showCrumbs?: boolean;
    /** Draw the filter row (and with it the sort control). */
    showFilterBar?: boolean;
    /**
     * surucu:d1-scope — `find` reduces the filter row to its name box (see
     * `FilterBar`'s own note). The host asks for it where the BODY is not a
     * listing of files at all — Home. It is NOT asked for at the multi-storage
     * root: a pane knows perfectly well when it is showing the drive list
     * (`atVirtualRoot`), and making the host say so for the main pane would
     * leave the split pane's own drive list with four chips that narrow nothing.
     */
    filterMode?: 'full' | 'find';
    /** What the name box says it narrows, already translated. Ignored at the
     *  drive root, which names itself. */
    findLabel?: string;
    /** Draw the view switcher in the address row. */
    showViewSwitcher?: boolean;
    /** Override for what the last crumb's "Subfolders" chevron lists. ⚠
     *  Optional, and normally omitted: the pane already HOLDS the folder's
     *  listing, so it answers "what is inside this folder" from its own rows.
     *  Passing it from the host is how only one pane ended up with the
     *  chevron. */
    crumbSubfolders?: {
        label: string;
        adapterPath: string;
    }[];
    /** Per-folder memory key, for the column menu's two folder rows. */
    folderKey?: string;
    /** Print each row's parent folder (a search, a cross-folder view). */
    showParentPath?: boolean;
    /** Paths that were cut — dimmed, and never dragged. */
    clipped?: Set<string>;
    /** A second narrowing composed AFTER this pane's own filter row (the
     *  advanced-search dialog's). Null when there is none. */
    extraFilters?: DriveFilters | null;
    canWrite?: boolean;
    canPaste?: boolean;
    selected: Set<string>;
    filters: DriveFilters;
    thumbSrc?: (n: FileNode) => string | null;
    keepBadgeFor?: (n: FileNode) => 'kept' | 'syncing' | 'cloud' | 'partial' | null;
    starredIds?: Set<number>;
    starEnabled?: boolean;
    apiBase?: string;
    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
    authCredentials?: RequestCredentials;
    /** No reading file bytes for a card preview inside an encrypted folder. */
    e2eActive?: boolean;
    /** The host is drawing the body itself (Home, a dead deep link, the
     *  encrypted lock screen) — those are WINDOW states with no listing
     *  behind them, so the pane's own state chain must not also run. */
    bodyOverride?: boolean;
    /** Mouse open gesture — 'double' (single selects, double opens) or
     *  'single' (first click opens). Touch always opens on tap; the checkbox
     *  always selects. See onViewClick. */
    openTrigger?: 'single' | 'double';
};

declare type __VLS_Props_16 = {
    open: boolean;
    locale: LocaleCode;
    /** True while the parent is creating the folder + uploading the marker. */
    busy?: boolean;
    /** Short id of this installation's E2E escrow key, when one is configured.
     *  Shown BEFORE the folder is created: escrow means the operator can open
     *  it without the password, and that is not a detail to discover later. */
    escrowKid?: string | null;
};

declare type __VLS_Props_17 = {
    open: boolean;
    locale: LocaleCode;
    /** The key itself. Shown, copied, downloaded — never emitted or stored. */
    recoveryKey: string;
    /** Folder name, for the downloaded file and the dialog copy. */
    folderName?: string;
    /** Set when this installation holds an escrow key for the folder too. */
    escrowKid?: string | null;
    /** 'created' = a new folder; 'upgraded' = an existing folder gained recovery. */
    variant?: 'created' | 'upgraded';
};

declare type __VLS_Props_18 = {
    open: boolean;
    locale: LocaleCode;
    /** The folder has a user recovery key slot (v2 markers created since 0.31). */
    hasRecovery: boolean;
    /**
     * Whether the escrow door applies to THIS folder — see escrowAvailability.
     * 'predates' and 'other-key' are not "no escrow tab"; they are two
     * different facts the dialog has to state, because an admin who knows the
     * installation has escrow reads a missing tab as a bug and tries the key
     * anyway.
     */
    escrowState: EscrowAvailability;
    /** Short id of the escrow key THIS FOLDER was sealed to, when it has one. */
    escrowKid?: string | null;
    busy?: boolean;
    /** Set by the parent after a failed attempt. */
    error?: string | null;
};

declare type __VLS_Props_19 = {
    config: ExplorerConfig;
    /** Which half to open on. */
    initialTab?: 'storages' | 'connect';
    /** Draw a close control — the desktop app opens this as a full surface
     *  and needs a way out; a page-embedded copy has the page's own chrome. */
    closable?: boolean;
};

declare type __VLS_Props_2 = {
    open: boolean;
    locale: LocaleCode;
    file: FileNode | null;
    previewUrl: (path: string) => string;
    downloadUrl: (path: string) => string;
    onlyOfficeBase?: string | null;
    onlyOfficeConfigEndpoint?: string | null;
    saveTextEndpoint?: string | null;
    /** Endpoint for the archive (zip/rar/7z/tar) member list. Forwarded to
     *  ArchiveViewer, which otherwise assumes a same-origin path. */
    archiveListEndpoint?: string | null;
    openMode?: 'edit' | 'view';
    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
    authCredentials?: RequestCredentials;
    /** New rich-viewer config (forwarded by FileExplorer from ExplorerConfig). */
    drawioUrl?: string | null;
    pdfWorkerUrl?: string | null;
    pdfSaveUrl?: string | null;
    /** Standalone full-screen viewer route — `?path=…&storage=…&type=…`. */
    viewerBaseUrl?: string | null;
    newTabEnabled?: boolean;
    /** Drop the dialog chrome (backdrop tint, header bar, footer actions)
     *  so the viewer fills the full viewport. Used by the standalone
     *  /files/edit route where the browser tab IS the container — a
     *  modal frame on top of the editor just steals real estate. */
    chromeless?: boolean;
    /** When the dynamic-viewer chunk fails to load, fall back to the
     *  legacy native renderer (e.g. native `<object>` for PDFs). */
    /** Explicit theme. Forwarded to the underlying Modal (which tags
     *  its backdrop with `.fe--theme-{light,dark}` so the CSS variable
     *  override matches the host admin shell) and to Monaco (vs vs
     *  vs-dark). When unset Monaco falls back to `prefers-color-scheme`
     *  and the modal cascade follows whatever `.fe` parent it gets. */
    theme?: 'light' | 'dark' | 'auto';
    /** 1-based position of `file` in the host's current file list. */
    index?: number;
    /** How many files that list holds. `index` + `total` draw "1 of 9";
     *  with either missing the counter is simply absent — a counter that
     *  guesses is worse than no counter. */
    total?: number;
    /** Draw the prev/next chevrons even when index/total are unknown.
     *  QuickLook sets it because its host already answers `nav`. */
    navEnabled?: boolean;
    /** API origin for the star toggle — same meaning as ExplorerConfig.apiBase.
     *  Omitted = same origin, which is what the admin UI wants. */
    apiBase?: string;
    /** Draw the share action. Off by default on purpose: a share button with
     *  no host listening to `@share` is a control that lies. */
    shareEnabled?: boolean;
};

declare type __VLS_Props_20 = {
    fields: StorageField[];
    modelValue: Record<string, unknown>;
    locale: LocaleCode;
    /** Keys to mark as failing validation (missing required). */
    invalid?: string[];
    disabled?: boolean;
};

declare type __VLS_Props_21 = {
    guide: ProtocolGuide;
    locale: LocaleCode;
};

declare type __VLS_Props_22 = {
    config: ExplorerConfig;
    /** Storage names the caller may see, for the confinement picker. */
    storages: string[];
};

declare type __VLS_Props_23 = {
    config: ExplorerConfig;
    /**
     * Draw the key list and the paste box.
     *
     * ⚠ False for FTPS, which authenticates with a password or an API token and
     * has no use for an SSH key — the panel is still MOUNTED there because it is
     * the call that reports where the FTP endpoint listens and under what login
     * name. Showing a key box on the FTPS page would invite somebody to register
     * a key that protocol will never look at.
     */
    keysVisible?: boolean;
};

declare type __VLS_Props_24 = {
    config: ExplorerConfig;
    /** Storage names the caller may see, for the confinement picker. */
    storages: string[];
};

declare type __VLS_Props_25 = {
    config: ExplorerConfig;
    /**
     * Render the full self-service key manager (scopes, folder confinement,
     * expiry) instead of the one-field minter the guides embed.
     */
    full?: boolean;
    /**
     * Which protocol the surrounding guide is showing. It only changes the
     * default label — a token minted here works on all of them, and pretending
     * otherwise would have people mint one per protocol.
     */
    protocol?: string;
    /**
     * The host the surrounding guide tells people to connect to. Given by the
     * connection guides, which know the server's own public address; without
     * it the label falls back to where this panel was loaded from. ⚠ The
     * default label used to be built from apiBase / the page while the guide
     * right under it printed the server's address — one screen, two machines.
     */
    host?: string;
};

declare type __VLS_Props_3 = {
    starred: boolean;
    nodeId: number;
    apiBase?: string;
    /** Auth header builder injected by the parent file explorer. */
    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
    /** Credentials mode, from the explorer's auth kind. ⚠ Defaults to
     *  'same-origin': a credentialed cross-origin request cannot be answered
     *  with ACAO:* , so hardcoding 'include' broke this call in every embed
     *  served from a different origin to the API. */
    authCredentials?: RequestCredentials;
    /** Compact mode for grid view (no label, just the icon). */
    compact?: boolean;
    /**
     * Card mode — the same button sitting ON a grid/gallery tile instead of in
     * a list cell: a round translucent chip in the tile's corner. It is the SAME
     * component, deliberately: a card star written separately is a second
     * starring path, and the two drift the first time one of them is fixed.
     */
    card?: boolean;
    /** Locale for the title/label. ⚠ The strings used to be hardcoded English
     *  ("Star"/"Unstar"), which is a Turkish user's only untranslated control in
     *  the row. */
    locale?: LocaleCode;
};

declare type __VLS_Props_4 = {
    nodeId: number;
    /**
     * ⚠ Added 2026-09-13 with the chip's new "open this tag" affordance, and it
     * pulls three OLDER strings out of English with it: this component printed
     * "+ Add tag", "tag name" and "Remove tag" literally, so a Turkish user
     * reading "Etiketler" as the section heading got three English controls under
     * it. Optional, defaulting to the catalogue's own default, so an embedder
     * that never passed one is unaffected.
     */
    locale?: LocaleCode;
    apiBase?: string;
    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
    /** Credentials mode, from the explorer's auth kind. ⚠ Defaults to
     *  'same-origin': a credentialed cross-origin request cannot be answered
     *  with ACAO:* , so hardcoding 'include' broke this call in every embed
     *  served from a different origin to the API. */
    authCredentials?: RequestCredentials;
    /** Optional list of palette swatches; one is picked per tag deterministically. */
    palette?: string[];
};

declare type __VLS_Props_5 = {
    apiBase?: string;
    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
    /** Credentials mode, from the explorer's auth kind. ⚠ Defaults to
     *  'same-origin': a credentialed cross-origin request cannot be answered
     *  with ACAO:* , so hardcoding 'include' broke this call in every embed
     *  served from a different origin to the API. */
    authCredentials?: RequestCredentials;
    limit?: number;
    /** Optional refresh trigger — incrementing this re-fetches. */
    refreshKey?: number | string;
};

declare type __VLS_Props_6 = {
    open: boolean;
    locale: LocaleCode;
    theme?: ThemeMode;
    /** The host's API wrapper — the dialog does its own listing + create. */
    api: FileApi;
    /**
     * `capabilities.newdoc_types`. Undefined/null on a server that predates the
     * feature; the host should not offer the entry at all in that case, and if
     * it does anyway the dialog degrades to its empty state rather than guessing.
     */
    types?: NewDocType[] | null;
    /** Adapter-qualified folder in view, e.g. `main://docs`. Empty at the root. */
    currentPath: string;
    /** Storage names, for the destination browser's top level. */
    storages?: string[];
    /** Resolved by the host: is there a usable OnlyOffice / drawio? */
    onlyOfficeReady?: boolean;
    drawioReady?: boolean;
};

declare type __VLS_Props_7 = {
    open: boolean;
    api: Pick<FileApi, 'index'>;
    locale: LocaleCode;
    /** Storage names. More than one adds a drives level above the roots. */
    storages?: string[];
    /** Wire path to open at — normally the folder the user is looking at. */
    startAt?: string;
    /**
     * Folders that must not be offered: what is being moved. A destination equal
     * to one of these, or inside one, is shown greyed with a reason rather than
     * hidden, because a folder that silently vanishes reads as data loss.
     */
    moving?: string[];
    /** Titles the dialog and names its confirm button. */
    mode?: 'move' | 'copy' | 'choose';
    /** The parent is running the operation: the dialog stays up but inert. */
    busy?: boolean;
};

declare type __VLS_Props_8 = {
    open: boolean;
    locale: LocaleCode;
    /** Host mode (forwarded to Modal so the backdrop themes correctly). */
    theme?: ThemeMode;
    /** Resolved mode — decides which variant the preview cards paint. */
    dark: boolean;
    /** Currently selected theme id. */
    current: string;
    /** The user's own light/dark preference; 'host' = never chosen. */
    mode: ThemeModePref;
    /** What the embedder asked for — what 'host' resolves to. */
    hostMode: ThemeMode;
};

declare type __VLS_Props_9 = {
    locale: LocaleCode;
    /** Resolved mode — decides which variant the preview cards paint. */
    dark: boolean;
    /** Currently selected theme id. */
    current: string;
    /** Draw the explanatory line above the grid. Default true. */
    hint?: boolean;
};

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        brand?(_: {}): any;
        'header-actions'?(_: {}): any;
    };
    refs: {
        rootEl: HTMLDivElement;
        toolbarRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly viewMode: ViewMode;
                readonly searchQuery: string;
                readonly trashActive: boolean;
                readonly actions: ContextAction[];
                readonly selectionMode?: SelectionMode_2 | undefined;
                readonly selectionCount?: number | undefined;
                readonly selectionPane?: string | undefined;
                readonly pasteEnabled?: boolean | undefined;
                readonly convertEnabled?: boolean | undefined;
                readonly canGoUp?: boolean | undefined;
                readonly atVirtualRoot?: boolean | undefined;
                readonly canWrite?: boolean | undefined;
                readonly locale: LocaleCode;
                readonly narrow?: boolean | undefined;
                readonly theme?: ThemeMode | undefined;
                readonly inspectorOpen?: boolean | undefined;
                readonly navOpen?: boolean | undefined;
                readonly navEnabled?: boolean | undefined;
                readonly viewModes?: ViewMode[] | undefined;
                readonly scopeLabel?: string | undefined;
                readonly brandName?: string | undefined;
                readonly brandMarkUrl?: string | undefined;
                readonly searchEscalates?: boolean | undefined;
                readonly onAction?: ((key: string) => any) | undefined;
                readonly onUpload?: (() => any) | undefined;
                readonly "onGo-up"?: (() => any) | undefined;
                readonly "onNew-folder"?: (() => any) | undefined;
                readonly onRefresh?: (() => any) | undefined;
                readonly "onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
                readonly "onUpdate:searchQuery"?: ((v: string) => any) | undefined;
                readonly "onOpen-advanced-search"?: ((v: string) => any) | undefined;
                readonly "onOpen-recents"?: (() => any) | undefined;
                readonly "onUpdate:density"?: ((v: Density) => any) | undefined;
                readonly "onToggle-inspector"?: (() => any) | undefined;
                readonly "onToggle-nav"?: (() => any) | undefined;
                readonly "onOpen-theme"?: (() => any) | undefined;
                readonly "onOpen-shortcut-settings"?: (() => any) | undefined;
                readonly "onOpen-timezone"?: (() => any) | undefined;
                readonly "onOpen-palette"?: ((query: string) => any) | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: Attrs;
            $refs: {
                [x: string]: unknown;
            } & {
                rootEl: HTMLDivElement;
                searchEl: HTMLInputElement;
                moreBtnEl: HTMLButtonElement;
                moreRef: CreateComponentPublicInstanceWithMixins<Readonly<{
                locale: LocaleCode;
                actions: ContextAction[];
                theme?: ThemeMode;
                sheet?: boolean;
                }> & Readonly<{
                onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
                }>, {
                show: (ev: {
                clientX: number;
                clientY: number;
                }, nodes: FileNode[]) => Promise<void>;
                hide: () => void;
                }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
                select: (action: ContextAction, target: FileNode[]) => any;
                }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
                sheetEl: HTMLDivElement;
                menuEl: HTMLDivElement;
                }, any, ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
                }, Readonly<{
                locale: LocaleCode;
                actions: ContextAction[];
                theme?: ThemeMode;
                sheet?: boolean;
                }> & Readonly<{
                onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
                }>, {
                show: (ev: {
                clientX: number;
                clientY: number;
                }, nodes: FileNode[]) => Promise<void>;
                hide: () => void;
                }, {}, {}, {}, {}> | null;
                selBarEl: HTMLDivElement;
                selMoreBtnEl: HTMLButtonElement;
                measureEl: HTMLDivElement;
                selMoreRef: CreateComponentPublicInstanceWithMixins<Readonly<{
                locale: LocaleCode;
                actions: ContextAction[];
                theme?: ThemeMode;
                sheet?: boolean;
                }> & Readonly<{
                onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
                }>, {
                show: (ev: {
                clientX: number;
                clientY: number;
                }, nodes: FileNode[]) => Promise<void>;
                hide: () => void;
                }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
                select: (action: ContextAction, target: FileNode[]) => any;
                }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
                sheetEl: HTMLDivElement;
                menuEl: HTMLDivElement;
                }, any, ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
                }, Readonly<{
                locale: LocaleCode;
                actions: ContextAction[];
                theme?: ThemeMode;
                sheet?: boolean;
                }> & Readonly<{
                onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
                }>, {
                show: (ev: {
                clientX: number;
                clientY: number;
                }, nodes: FileNode[]) => Promise<void>;
                hide: () => void;
                }, {}, {}, {}, {}> | null;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "action", key: string) => void) & ((event: "upload") => void) & ((event: "go-up") => void) & ((event: "new-folder") => void) & ((event: "refresh") => void) & ((event: "update:viewMode", v: ViewMode) => void) & ((event: "update:searchQuery", v: string) => void) & ((event: "open-advanced-search", v: string) => void) & ((event: "open-recents") => void) & ((event: "update:density", v: Density) => void) & ((event: "toggle-inspector") => void) & ((event: "toggle-nav") => void) & ((event: "open-theme") => void) & ((event: "open-shortcut-settings") => void) & ((event: "open-timezone") => void) & ((event: "open-palette", query: string) => void);
            $el: HTMLDivElement;
            $options: ComponentOptionsBase<Readonly<{
            viewMode: ViewMode;
            searchQuery: string;
            trashActive: boolean;
            actions: ContextAction[];
            selectionMode?: SelectionMode_2;
            selectionCount?: number;
            selectionPane?: string;
            pasteEnabled?: boolean;
            convertEnabled?: boolean;
            canGoUp?: boolean;
            atVirtualRoot?: boolean;
            canWrite?: boolean;
            locale: LocaleCode;
            narrow?: boolean;
            theme?: ThemeMode;
            inspectorOpen?: boolean;
            navOpen?: boolean;
            navEnabled?: boolean;
            viewModes?: ViewMode[];
            scopeLabel?: string;
            brandName?: string;
            brandMarkUrl?: string;
            searchEscalates?: boolean;
            }> & Readonly<{
            onAction?: ((key: string) => any) | undefined;
            onUpload?: (() => any) | undefined;
            "onGo-up"?: (() => any) | undefined;
            "onNew-folder"?: (() => any) | undefined;
            onRefresh?: (() => any) | undefined;
            "onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
            "onUpdate:searchQuery"?: ((v: string) => any) | undefined;
            "onOpen-advanced-search"?: ((v: string) => any) | undefined;
            "onOpen-recents"?: (() => any) | undefined;
            "onUpdate:density"?: ((v: Density) => any) | undefined;
            "onToggle-inspector"?: (() => any) | undefined;
            "onToggle-nav"?: (() => any) | undefined;
            "onOpen-theme"?: (() => any) | undefined;
            "onOpen-shortcut-settings"?: (() => any) | undefined;
            "onOpen-timezone"?: (() => any) | undefined;
            "onOpen-palette"?: ((query: string) => any) | undefined;
            }>, {
            focusSearch: () => Promise<void>;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
            action: (key: string) => any;
            upload: () => any;
            "go-up": () => any;
            "new-folder": () => any;
            refresh: () => any;
            "update:viewMode": (v: ViewMode) => any;
            "update:searchQuery": (v: string) => any;
            "open-advanced-search": (v: string) => any;
            "open-recents": () => any;
            "update:density": (v: Density) => any;
            "toggle-inspector": () => any;
            "toggle-nav": () => any;
            "open-theme": () => any;
            "open-shortcut-settings": () => any;
            "open-timezone": () => any;
            "open-palette": (query: string) => any;
            }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof nextTick;
            $watch<T extends string | ((
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: any) => any)>(source: T, cb: T extends (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: any) => infer R ? (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: [R, R, OnCleanup]) => any : (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{}> & Omit<Readonly<{
            viewMode: ViewMode;
            searchQuery: string;
            trashActive: boolean;
            actions: ContextAction[];
            selectionMode?: SelectionMode_2;
            selectionCount?: number;
            selectionPane?: string;
            pasteEnabled?: boolean;
            convertEnabled?: boolean;
            canGoUp?: boolean;
            atVirtualRoot?: boolean;
            canWrite?: boolean;
            locale: LocaleCode;
            narrow?: boolean;
            theme?: ThemeMode;
            inspectorOpen?: boolean;
            navOpen?: boolean;
            navEnabled?: boolean;
            viewModes?: ViewMode[];
            scopeLabel?: string;
            brandName?: string;
            brandMarkUrl?: string;
            searchEscalates?: boolean;
        }> & Readonly<{
            onAction?: ((key: string) => any) | undefined;
            onUpload?: (() => any) | undefined;
            "onGo-up"?: (() => any) | undefined;
            "onNew-folder"?: (() => any) | undefined;
            onRefresh?: (() => any) | undefined;
            "onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
            "onUpdate:searchQuery"?: ((v: string) => any) | undefined;
            "onOpen-advanced-search"?: ((v: string) => any) | undefined;
            "onOpen-recents"?: (() => any) | undefined;
            "onUpdate:density"?: ((v: Density) => any) | undefined;
            "onToggle-inspector"?: (() => any) | undefined;
            "onToggle-nav"?: (() => any) | undefined;
            "onOpen-theme"?: (() => any) | undefined;
            "onOpen-shortcut-settings"?: (() => any) | undefined;
            "onOpen-timezone"?: (() => any) | undefined;
            "onOpen-palette"?: ((query: string) => any) | undefined;
        }>, "focusSearch"> & {
            focusSearch: () => Promise<void>;
        } & {} & ComponentCustomProperties & {} & {
            $slots: {
                brand?(_: {}): any;
                'header-actions'?(_: {}): any;
                'header-actions'?(_: {}): any;
            };
        }) | null;
        mainPaneRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
                readonly paneId: PaneId;
                readonly api: FileApi;
                readonly locale: LocaleCode;
                readonly theme?: ThemeMode | undefined;
                readonly focused?: boolean | undefined;
                readonly closable?: boolean | undefined;
                readonly path: string;
                readonly selfDriven?: boolean | undefined;
                readonly qualify: (p: string) => string;
                readonly toUser: (wire: string) => string;
                readonly clamp: (p: string) => string;
                readonly rootLabel?: string | undefined;
                readonly rootPath?: string | undefined;
                readonly floor?: string | undefined;
                readonly multiRoot?: boolean | undefined;
                readonly virtualRows?: (() => FileNode[]) | undefined;
                readonly trashVisible?: boolean | undefined;
                readonly navOffersTrash?: boolean | undefined;
                readonly rows?: FileNode[] | undefined;
                readonly loading?: boolean | undefined;
                readonly error?: string | undefined;
                readonly order?: ListingOrder | undefined;
                readonly viewMode: ViewMode;
                readonly viewModes?: ViewMode[] | undefined;
                readonly showCrumbs?: boolean | undefined;
                readonly showFilterBar?: boolean | undefined;
                readonly filterMode?: "full" | "find" | undefined;
                readonly findLabel?: string | undefined;
                readonly showViewSwitcher?: boolean | undefined;
                readonly crumbSubfolders?: {
                    label: string;
                    adapterPath: string;
                }[] | undefined;
                readonly folderKey?: string | undefined;
                readonly showParentPath?: boolean | undefined;
                readonly clipped?: Set<string> | undefined;
                readonly extraFilters?: (DriveFilters | null) | undefined;
                readonly canWrite?: boolean | undefined;
                readonly canPaste?: boolean | undefined;
                readonly selected: Set<string>;
                readonly filters: DriveFilters;
                readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
                readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
                readonly starredIds?: Set<number> | undefined;
                readonly starEnabled?: boolean | undefined;
                readonly apiBase?: string | undefined;
                readonly authHeaders?: (() => Record<string, string> | Promise<Record<string, string>>) | undefined;
                readonly authCredentials?: RequestCredentials | undefined;
                readonly e2eActive?: boolean | undefined;
                readonly bodyOverride?: boolean | undefined;
                readonly openTrigger?: "single" | "double" | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: Attrs;
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: HTMLElement;
            $options: ComponentOptionsBase<Readonly<{
            paneId: PaneId;
            api: FileApi;
            locale: LocaleCode;
            theme?: ThemeMode;
            focused?: boolean;
            closable?: boolean;
            path: string;
            selfDriven?: boolean;
            qualify: (p: string) => string;
            toUser: (wire: string) => string;
            clamp: (p: string) => string;
            rootLabel?: string;
            rootPath?: string;
            floor?: string;
            multiRoot?: boolean;
            virtualRows?: () => FileNode[];
            trashVisible?: boolean;
            navOffersTrash?: boolean;
            rows?: FileNode[];
            loading?: boolean;
            error?: string;
            order?: ListingOrder;
            viewMode: ViewMode;
            viewModes?: ViewMode[];
            showCrumbs?: boolean;
            showFilterBar?: boolean;
            filterMode?: "full" | "find";
            findLabel?: string;
            showViewSwitcher?: boolean;
            crumbSubfolders?: {
            label: string;
            adapterPath: string;
            }[];
            folderKey?: string;
            showParentPath?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starEnabled?: boolean;
            apiBase?: string;
            authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
            authCredentials?: RequestCredentials;
            e2eActive?: boolean;
            bodyOverride?: boolean;
            openTrigger?: "single" | "double";
            }> & Readonly<{
            [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
            }>, {
            reload: () => Promise<void>;
            goUp: () => void;
            getPath: () => string;
            visibleNodes: () => FileNode[];
            loadFolder: (target?: string) => Promise<void>;
            rowCount: () => number;
            rowPaths: () => string[];
            dirPerm: () => string;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
            [x: string]: any;
            }, string, {
            trashVisible: boolean;
            showCrumbs: boolean;
            showFilterBar: boolean;
            showViewSwitcher: boolean;
            openTrigger: "single" | "double";
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof nextTick;
            $watch<T extends string | ((
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: any) => any)>(source: T, cb: T extends (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: any) => infer R ? (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: [R, R, OnCleanup]) => any : (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            trashVisible: boolean;
            showCrumbs: boolean;
            showFilterBar: boolean;
            showViewSwitcher: boolean;
            openTrigger: "single" | "double";
        }> & Omit<Readonly<{
            paneId: PaneId;
            api: FileApi;
            locale: LocaleCode;
            theme?: ThemeMode;
            focused?: boolean;
            closable?: boolean;
            path: string;
            selfDriven?: boolean;
            qualify: (p: string) => string;
            toUser: (wire: string) => string;
            clamp: (p: string) => string;
            rootLabel?: string;
            rootPath?: string;
            floor?: string;
            multiRoot?: boolean;
            virtualRows?: () => FileNode[];
            trashVisible?: boolean;
            navOffersTrash?: boolean;
            rows?: FileNode[];
            loading?: boolean;
            error?: string;
            order?: ListingOrder;
            viewMode: ViewMode;
            viewModes?: ViewMode[];
            showCrumbs?: boolean;
            showFilterBar?: boolean;
            filterMode?: "full" | "find";
            findLabel?: string;
            showViewSwitcher?: boolean;
            crumbSubfolders?: {
                label: string;
                adapterPath: string;
            }[];
            folderKey?: string;
            showParentPath?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starEnabled?: boolean;
            apiBase?: string;
            authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
            authCredentials?: RequestCredentials;
            e2eActive?: boolean;
            bodyOverride?: boolean;
            openTrigger?: "single" | "double";
        }> & Readonly<{
            [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
        }>, "reload" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowCount" | "rowPaths" | ("trashVisible" | "showCrumbs" | "showFilterBar" | "showViewSwitcher" | "openTrigger")> & {
            reload: () => Promise<void>;
            goUp: () => void;
            getPath: () => string;
            visibleNodes: () => FileNode[];
            loadFolder: (target?: string) => Promise<void>;
            rowCount: () => number;
            rowPaths: () => string[];
            dirPerm: () => string;
        } & {} & ComponentCustomProperties & {} & {
            $slots: {
                heading?(_: {}): any;
                banners?(_: {}): any;
                body?(_: {}): any;
                empty?(_: {}): any;
            };
        }) | null;
        splitPaneRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
                readonly paneId: PaneId;
                readonly api: FileApi;
                readonly locale: LocaleCode;
                readonly theme?: ThemeMode | undefined;
                readonly focused?: boolean | undefined;
                readonly closable?: boolean | undefined;
                readonly path: string;
                readonly selfDriven?: boolean | undefined;
                readonly qualify: (p: string) => string;
                readonly toUser: (wire: string) => string;
                readonly clamp: (p: string) => string;
                readonly rootLabel?: string | undefined;
                readonly rootPath?: string | undefined;
                readonly floor?: string | undefined;
                readonly multiRoot?: boolean | undefined;
                readonly virtualRows?: (() => FileNode[]) | undefined;
                readonly trashVisible?: boolean | undefined;
                readonly navOffersTrash?: boolean | undefined;
                readonly rows?: FileNode[] | undefined;
                readonly loading?: boolean | undefined;
                readonly error?: string | undefined;
                readonly order?: ListingOrder | undefined;
                readonly viewMode: ViewMode;
                readonly viewModes?: ViewMode[] | undefined;
                readonly showCrumbs?: boolean | undefined;
                readonly showFilterBar?: boolean | undefined;
                readonly filterMode?: "full" | "find" | undefined;
                readonly findLabel?: string | undefined;
                readonly showViewSwitcher?: boolean | undefined;
                readonly crumbSubfolders?: {
                    label: string;
                    adapterPath: string;
                }[] | undefined;
                readonly folderKey?: string | undefined;
                readonly showParentPath?: boolean | undefined;
                readonly clipped?: Set<string> | undefined;
                readonly extraFilters?: (DriveFilters | null) | undefined;
                readonly canWrite?: boolean | undefined;
                readonly canPaste?: boolean | undefined;
                readonly selected: Set<string>;
                readonly filters: DriveFilters;
                readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
                readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
                readonly starredIds?: Set<number> | undefined;
                readonly starEnabled?: boolean | undefined;
                readonly apiBase?: string | undefined;
                readonly authHeaders?: (() => Record<string, string> | Promise<Record<string, string>>) | undefined;
                readonly authCredentials?: RequestCredentials | undefined;
                readonly e2eActive?: boolean | undefined;
                readonly bodyOverride?: boolean | undefined;
                readonly openTrigger?: "single" | "double" | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: Attrs;
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: HTMLElement;
            $options: ComponentOptionsBase<Readonly<{
            paneId: PaneId;
            api: FileApi;
            locale: LocaleCode;
            theme?: ThemeMode;
            focused?: boolean;
            closable?: boolean;
            path: string;
            selfDriven?: boolean;
            qualify: (p: string) => string;
            toUser: (wire: string) => string;
            clamp: (p: string) => string;
            rootLabel?: string;
            rootPath?: string;
            floor?: string;
            multiRoot?: boolean;
            virtualRows?: () => FileNode[];
            trashVisible?: boolean;
            navOffersTrash?: boolean;
            rows?: FileNode[];
            loading?: boolean;
            error?: string;
            order?: ListingOrder;
            viewMode: ViewMode;
            viewModes?: ViewMode[];
            showCrumbs?: boolean;
            showFilterBar?: boolean;
            filterMode?: "full" | "find";
            findLabel?: string;
            showViewSwitcher?: boolean;
            crumbSubfolders?: {
            label: string;
            adapterPath: string;
            }[];
            folderKey?: string;
            showParentPath?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starEnabled?: boolean;
            apiBase?: string;
            authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
            authCredentials?: RequestCredentials;
            e2eActive?: boolean;
            bodyOverride?: boolean;
            openTrigger?: "single" | "double";
            }> & Readonly<{
            [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
            }>, {
            reload: () => Promise<void>;
            goUp: () => void;
            getPath: () => string;
            visibleNodes: () => FileNode[];
            loadFolder: (target?: string) => Promise<void>;
            rowCount: () => number;
            rowPaths: () => string[];
            dirPerm: () => string;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
            [x: string]: any;
            }, string, {
            trashVisible: boolean;
            showCrumbs: boolean;
            showFilterBar: boolean;
            showViewSwitcher: boolean;
            openTrigger: "single" | "double";
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof nextTick;
            $watch<T extends string | ((
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: any) => any)>(source: T, cb: T extends (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: any) => infer R ? (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: [R, R, OnCleanup]) => any : (
            /**
             * FileExplorer — the public Vue component, panel + PWA + standalone use.
             *
             * Orchestrates:
             *   - Directory listing (useFileApi)
             *   - Chunked multipart upload (useUploadChunked) + drag & drop
             *   - Selection + keyboard shortcuts
             *   - Context menu (Teleport-based) with per-target actions
             *   - Modal flows: newFolder / rename / delete / share / preview
             *   - Eager Monaco preload so the code-edit path is snappy
             *
             * All backend endpoints arrive via the `config` prop. Auth is bearer
             * (PWA / OIDC) / CSRF (panel) / basic / none — `useFileApi` swallows
             * the difference.
             */
            ...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            trashVisible: boolean;
            showCrumbs: boolean;
            showFilterBar: boolean;
            showViewSwitcher: boolean;
            openTrigger: "single" | "double";
        }> & Omit<Readonly<{
            paneId: PaneId;
            api: FileApi;
            locale: LocaleCode;
            theme?: ThemeMode;
            focused?: boolean;
            closable?: boolean;
            path: string;
            selfDriven?: boolean;
            qualify: (p: string) => string;
            toUser: (wire: string) => string;
            clamp: (p: string) => string;
            rootLabel?: string;
            rootPath?: string;
            floor?: string;
            multiRoot?: boolean;
            virtualRows?: () => FileNode[];
            trashVisible?: boolean;
            navOffersTrash?: boolean;
            rows?: FileNode[];
            loading?: boolean;
            error?: string;
            order?: ListingOrder;
            viewMode: ViewMode;
            viewModes?: ViewMode[];
            showCrumbs?: boolean;
            showFilterBar?: boolean;
            filterMode?: "full" | "find";
            findLabel?: string;
            showViewSwitcher?: boolean;
            crumbSubfolders?: {
                label: string;
                adapterPath: string;
            }[];
            folderKey?: string;
            showParentPath?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starEnabled?: boolean;
            apiBase?: string;
            authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
            authCredentials?: RequestCredentials;
            e2eActive?: boolean;
            bodyOverride?: boolean;
            openTrigger?: "single" | "double";
        }> & Readonly<{
            [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
        }>, "reload" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowCount" | "rowPaths" | ("trashVisible" | "showCrumbs" | "showFilterBar" | "showViewSwitcher" | "openTrigger")> & {
            reload: () => Promise<void>;
            goUp: () => void;
            getPath: () => string;
            visibleNodes: () => FileNode[];
            loadFolder: (target?: string) => Promise<void>;
            rowCount: () => number;
            rowPaths: () => string[];
            dirPerm: () => string;
        } & {} & ComponentCustomProperties & {} & {
            $slots: {
                heading?(_: {}): any;
                banners?(_: {}): any;
                body?(_: {}): any;
                empty?(_: {}): any;
            };
        }) | null;
        ctxRef: CreateComponentPublicInstanceWithMixins<Readonly<{
        locale: LocaleCode;
        actions: ContextAction[];
        theme?: ThemeMode;
        sheet?: boolean;
        }> & Readonly<{
        onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
        }>, {
        show: (ev: {
        clientX: number;
        clientY: number;
        }, nodes: FileNode[]) => Promise<void>;
        hide: () => void;
        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
        select: (action: ContextAction, target: FileNode[]) => any;
        }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
        sheetEl: HTMLDivElement;
        menuEl: HTMLDivElement;
        }, any, ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
        }, Readonly<{
        locale: LocaleCode;
        actions: ContextAction[];
        theme?: ThemeMode;
        sheet?: boolean;
        }> & Readonly<{
        onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
        }>, {
        show: (ev: {
        clientX: number;
        clientY: number;
        }, nodes: FileNode[]) => Promise<void>;
        hide: () => void;
        }, {}, {}, {}, {}> | null;
        fileInputEl: HTMLInputElement;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_2(): {
    attrs: Partial<{}>;
    slots: {
        heading?(_: {}): any;
        banners?(_: {}): any;
        body?(_: {}): any;
        empty?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLElement;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

/**
 * Where the ticket URL should be fetched from.
 *
 * The server answers a server-relative `/z/<token>`, which is correct for the
 * same-origin case and wrong for an embed whose API lives on another host. The
 * origin comes from the manager URL, which is the one thing that is always
 * right.
 */
export declare function absoluteTicketUrl(managerUrl: string, ticketUrl: string): string;

/** The account zone `owner` last recorded (`null` = none recorded). Reactive. */
export declare function accountTimeZoneOf(owner: symbol): string | null;

/** Every key this module draws — handy for tests and for a gallery page. */
export declare function actionIconKeys(): string[];

/**
 * actionIcons — menu/toolbar ACTION key → inline SVG icon mapping.
 *
 * The sibling of `lib/fileIcons.ts`, for the other half of the problem: that
 * module draws what a row IS (a folder, a sheet, an archive), this one draws
 * what a row DOES (open, rename, move to trash).
 *
 * Why it exists: the action rows used to carry emoji (`↗ 👁 ⬇ 🗑 …`). Emoji are
 * not one icon set — they are a dozen sets, rendered by whatever font the OS
 * happens to ship, at whatever weight and colour that font's designer chose.
 * Two rows of the same menu could come out flat-grey and full-colour, one
 * hairline and one bold, and none of them matched the file glyphs drawn four
 * pixels to the left. A stroked set on `currentColor` gives the menu one voice
 * and lets the row's own colour reach the icon — which is how the destructive
 * entry, and only the destructive entry, comes out red.
 *
 * Conventions are `fileIcons.ts`'s, deliberately: static strings (so `v-html`
 * is injecting markup this file wrote, never user input), one cache, 24×24
 * viewBox, 1.6 stroke, round caps/joins, `currentColor`.
 *
 * Adding a key: draw it here. Nothing else has to change — the renderers ask
 * for the icon by the action's own key, so a new action gets its icon the
 * moment its glyph lands in GLYPHS, and an action with no glyph renders
 * nothing (the caller falls back to whatever `icon` string it was handed, so
 * an embedder's custom emoji still shows).
 */
/**
 * Inline SVG markup for an action key, or `''` when nothing is drawn for it.
 *
 * The empty string is a contract, not a failure: the caller renders nothing
 * (or falls back to the `icon` string an embedder supplied) rather than a
 * placeholder box, so an unknown key costs a gap and never a broken glyph.
 */
export declare function actionIconSvg(key: string): string;

/**
 * The zone to hand `Intl` — the resolved one. Reactive: reading it inside a
 * render or a computed subscribes that surface to every tier.
 *
 * `undefined` is returned for the device rather than the resolved name, so the
 * formatter takes `Intl`'s own live answer (a laptop carried across an ocean
 * keeps telling the truth without anybody re-saving anything).
 */
export declare function activeTimeZone(): string | undefined;

/**
 * Give an EXISTING v2 folder an escrow slot, in place, using the folder
 * password its owner has just typed.
 *
 * ── Why this exists ─────────────────────────────────────────────────
 *
 * Escrow used to be all-or-nothing at install time, and then adoptable but
 * never retroactive: on any installation that had been running for a while,
 * escrow covered only folders nobody had created yet. On a real deployment
 * the folders that matter already exist, so "new folders only" means escrow
 * covers nothing anyone cares about.
 *
 * The server still cannot do this, and that has not changed: adding a slot
 * needs the folder master key, which needs a credential the server has never
 * held. What CAN do it is the browser, at the one moment the password is in
 * memory — exactly where `upgradeMarkerV1` already lives. Same moment, same
 * shape, different slot.
 *
 * ⚠⚠ Accepting hands the operator of this installation a second, permanent
 * way into this folder. It is the folder's owner who decides, from inside,
 * with the password; no configuration change and no admin action can do it
 * for them. The caller MUST say that in those words before calling this —
 * see `e2e.escrowoffer.*` in the locales.
 *
 * ⚠ v2 only. A v1 marker has no slots at all; the path for those is
 * `upgradeMarkerV1`, which already seals an escrow slot when the
 * installation has a key and already discloses it. Two doors into the same
 * room would be two chances to get the disclosure wrong.
 *
 * ⚠ No file is re-encrypted, moved or rewritten. Only `.filex-e2e.json`
 * changes, and only by gaining `esc` (and losing `esc_declined`).
 */
export declare function addEscrowSlot(marker: E2eMarker, password: string, escrowPublicKey: string): Promise<E2eMarker>;

/**
 * The self-service API-token surface (`/api/tokens`).
 *
 * ⚠ Why this exists at all: three of the six protocols filex serves take an
 * API token as their password — FTPS, WebDAV and `filex mount`. Until
 * 2026-08-17 the only place to mint one was `/api/admin/ai-tokens`, which is
 * admin-only, so a normal user opened the FTPS guide, read "use an API token
 * as the password", and had nowhere to get one. The backend route has always
 * been open to every account; only the UI was missing.
 */
/** One token row. The secret is NEVER in here — only the hash is stored. */
export declare interface ApiToken {
    id: number;
    label: string;
    scopes: string;
    /** Per-token display identities for the audit trail; may be absent. */
    usernames?: string | null;
    created_at?: string;
    last_used_at?: string | null;
    expires_at?: string | null;
}

/** What comes back from a mint. `token` is shown exactly once. */
export declare interface ApiTokenCreated {
    token: string;
    row: ApiToken;
}

export declare interface ApiTokenRequest {
    label: string;
    /**
     * Comma-separated verbs. The server CAPS this against the caller's role and
     * their own grants, so asking for more than you have is refused rather than
     * quietly granted — never send `admin`, it is rejected outright here.
     */
    scopes?: string;
    expires_in_days?: number;
}

/**
 * Set (or clear, for the default theme) the selected theme's tokens as
 * inline CSS variables on the explorer root element, resolved to the
 * active variant. Inline style wins over every stylesheet rule, so the
 * root subtree is always correct regardless of host CSS.
 */
export declare function applyThemeToEl(el: HTMLElement, id: string, dark: boolean): void;

export declare interface ArchiveEntry {
    name: string;
    size: number;
    isDir: boolean;
    lastModified?: number;
}

/** What the mint returns. Mirrors `archiveDownloadInfo` in the Go handler. */
export declare interface ArchiveTicket {
    /** Path to navigate to. Server-relative, e.g. `/z/<token>`. */
    url: string;
    ticket: string;
    /** Filename the browser will save, e.g. `Faturalar.zip`. */
    name: string;
    /** How many files the archive will contain, after the server expanded any
     *  selected folders and dropped what the caller may not read. */
    files: number;
    /** Uncompressed total. NOT the archive's size — see the Go handler on why
     *  there is no such number until the last member is deflated. */
    bytes: number;
    expires_at: string;
}

/**
 * The mint endpoint for a given manager URL.
 *
 * Derived by swapping the trailing `/manager` segment, which is how every
 * route outside the endpoint map is built in useFileApi (`/permissions`,
 * `/versions`, `/comments`, `/ws-ticket`). Doing it this way rather than
 * hardcoding `/api/files/...` is what keeps a cross-origin embed working: the
 * host configured `apiBase`, and the archive call has to land on the same
 * origin as the rest of the explorer.
 */
export declare function archiveTicketUrl(managerUrl: string): string;

/** gorunum:v1-advsearch — how wide "around" reaches on each side of the anchor. */
declare type AroundSpan = 'h1' | 'd1' | 'w1';

/** An item that is not filed under a date, and the run it belongs to instead. */
declare interface AsideRun {
    id: string;
    /** A heading for that run, or null/absent for a run drawn without one. */
    label?: string | null;
}

/**
 * Hand this module its transport and read the document.
 *
 * Called once per explorer mount. Calling it again is a no-op on purpose: two
 * explorers on one page share this module's state, and the second must not
 * re-fetch over the first.
 */
export declare function attachViewPrefsStore(t: ViewPrefsTransport): void;

/**
 * Auth strategy. Discriminated union so request building is type-safe.
 *
 * - `bearer`  — `Authorization: Bearer <token>`. Token may be a string
 *               OR a sync/async function (auto-refresh).
 * - `csrf`    — `X-CSRF-TOKEN` + `credentials: include` (Laravel/Filament).
 * - `basic`   — `Authorization: Basic <base64(user:pass)>`.
 * - `none`    — no auth (development / public sandbox).
 */
export declare type AuthConfig = {
    kind: 'bearer';
    token: string | (() => string | Promise<string>);
} | {
    kind: 'csrf';
    csrf: string;
} | {
    kind: 'basic';
    user: string;
    pass: string;
} | {
    kind: 'none';
}
/**
* Legacy `type` field (back-compat with @brftech/file-explorer 0.1.0).
* Internally normalized to the `kind`-tagged shape.
*/
| {
    type: 'bearer';
    token: string;
} | {
    type: 'csrf';
    csrf: string;
};

/**
 * Why this folder cannot be the destination, or null when it can.
 *
 * `'self'` and `'descendant'` are kept apart because they need different
 * sentences. "You cannot move a folder into itself" and "…into a folder inside
 * it" are the two halves of the mistake, and a single message covering both
 * reads as a riddle at the moment the person is trying to work out what they
 * did wrong.
 *
 * ⚠ This is a courtesy, not a control. The same refusal exists in
 * `internal/ops.SubmitTo` and answers 400 whatever the picker offered —
 * measured on a live local storage 2026-09-13, where the API accepted the
 * request and the queue worker failed it minutes later with an errno.
 */
export declare function blockedReason(candidate: string, moving: string[] | undefined): 'self' | 'descendant' | null;

/**
 * Injection seam. The defaults touch the DOM and the network; tests replace
 * them so the classification logic can be asserted without either.
 */
export declare interface BrowserProbeDeps {
    loadScript(url: string, timeoutMs: number): Promise<'load' | 'error' | 'timeout'>;
    loadFramed(url: string, timeoutMs: number): Promise<'ready' | 'timeout'>;
    reachable(url: string): Promise<boolean>;
    hasDocsAPI(): boolean;
    pageProtocol(): string;
    now(): number;
}

export declare interface BrowserProbeResult {
    service: string;
    state: BrowserProbeState;
    /** The exact URL attempted — the same one the real viewer loads. */
    url: string;
    /** Milliseconds elapsed. Worth showing: a 6 s "unreachable" is a DNS story. */
    ms: number;
    mechanism: 'script' | 'iframe' | 'none';
}

/**
 * externalReach — "can THIS browser reach the external service?"
 *
 * # Why this exists
 *
 * Three machines must reach three addresses before the Office editor works,
 * and until now only one of them was ever checked:
 *
 * | address                | who must reach it                     | who checked it   |
 * | ---------------------- | ------------------------------------- | ---------------- |
 * | the Document Server URL| the **browser** (loads the editor JS) | nobody           |
 * | the Document Server URL| the filex process                     | the Test button  |
 * | `FILEX_PUBLIC_URL`     | the **document server** (fetch + save)| nobody           |
 *
 * So an operator on podman types `http://onlyoffice`, filex reaches it, Test
 * goes green, and the browser cannot resolve that name at all. The editor then
 * fails with the same message as a missing configuration — issue #17, twice.
 *
 * The admin page runs **in the browser that will actually open the editor**,
 * so it can answer the first row directly instead of disclaiming it. That is
 * what this module does.
 *
 * # Mechanism, and why not `fetch`
 *
 * ⚠ A plain `fetch()` is the obvious choice and the wrong one: a document
 * server that works perfectly will usually answer without CORS headers, the
 * promise rejects, and a naive `catch` reports failure for a healthy service.
 *
 * Instead each service is probed **the same way the real viewer loads it**:
 *
 * - **onlyoffice** — a `<script>` pointing at
 *   `<base>/web-apps/apps/api/documents/api.js`. Script `load`/`error` is not
 *   subject to CORS for load detection, and a successful load leaves
 *   `window.DocsAPI.DocEditor` defined, which proves the thing that answered
 *   really is a Document Server. (Verified against a live OnlyOffice Docs
 *   instance: `load` + `DocsAPI` in ~0.5 s.)
 * - **drawio** — a hidden `<iframe>` at `<base>/?embed=1&proto=json`, which
 *   posts `{"event":"init"}` to its parent when the editor is ready. Same
 *   handshake `DrawioViewer.vue` uses. (Verified against a live drawio.)
 *
 * Both distinguish **"could not reach"** from **"reached, wrong thing"** with
 * a second signal: a `no-cors` `fetch`, whose promise resolves for any HTTP
 * status and rejects only on a network-level failure. Reached + no editor =
 * `wrong-content`; not reached at all = `unreachable`.
 *
 * Every probe is bounded by a timeout and reports the timeout as its own
 * state, so a black-holed address stops the spinner instead of hanging.
 */
/** The result of one probe. Each value is a different sentence to the operator. */
export declare type BrowserProbeState = 
/** Loaded, and it really is the service it claims to be. */
'ok'
/** Something answered at that address, but it is not this service. */
| 'wrong-content'
/** Nothing answered: DNS failure, connection refused, blocked. */
| 'unreachable'
/** Nothing answered and nothing refused either — a black hole. */
| 'timeout'
/** The admin page is HTTPS and the service URL is HTTP; the browser will refuse. */
| 'blocked-mixed-content'
/** No URL configured, or a service with no browser-side entry point to probe. */
| 'skipped';

/** The URL each service is probed at — the same one its viewer loads. */
export declare function browserProbeURL(service: string, base: string): string;

/**
 * Every command here was RUN against the endpoint on 2026-08-16 with curl
 * 8.5, lftp 4.9 and rclone 1.73 — including the settings each of them needs to
 * negotiate explicit TLS, which is the half of FTPS that goes wrong quietly.
 */
export declare const buildFtpsGuide: GuideBuilder;

export declare function buildGuide(protocol: string, ctx: GuideContext, t: Translate): ProtocolGuide | null;

/**
 * Every command here was RUN against the endpoint on 2026-08-16 with the LINUX
 * KERNEL's own NFSv3 client — including the two options a mount fails silently
 * without (`port=` and `mountport=`, because filex serves both on one port and
 * runs no portmapper).
 */
export declare const buildNfsGuide: GuideBuilder;

/**
 * Every command here was RUN against the endpoint on 2026-08-16, not copied
 * from a vendor page: rclone 1.73.5, aws-cli 2.11.6, restic 0.19.1, mc
 * 2025-08-13 and s3fs 1.93 each did a full round trip, and the flags below are
 * the ones those runs actually needed. Five of the endpoint's bugs were found
 * that way — a guide assembled from documentation would have shipped them.
 */
export declare const buildS3Guide: GuideBuilder;

/**
 * Every command here was RUN against the endpoint on 2026-08-16 with OpenSSH
 * 9.6 and rclone 1.73 — including the two settings rclone needs because filex
 * has no shell, which are the difference between a clean run and a pile of
 * warnings about a missing `md5sum`.
 */
export declare const buildSftpGuide: GuideBuilder;

export declare const buildWebdavGuide: GuideBuilder;

export declare interface ByteSizeOptions {
    /** Resolve a unit key to its label. Default: the English short forms. */
    unit?: (key: ByteUnitKey) => string;
    /**
     * Tag for the NUMBER itself — decimal separator and grouping. `null` (the
     * default) is the C locale: a dot, no grouping, deterministic. Pass the
     * viewer's tag on any surface a person reads, so Turkish gets "1,43 MB".
     */
    numberLocale?: string | null;
    /**
     * 1000 (the default) or 1024. See the note on `formatByteSize` — 1024 is
     * for mirroring some OTHER system's arithmetic, never a style choice.
     */
    base?: 1000 | 1024;
    /** `fixed1` always shows one decimal above B, like the server's humanSize(). */
    digits?: 'auto' | 'fixed1';
    /** What "no size at all" renders as. */
    empty?: string;
}

export declare type ByteUnitKey = 'unit.bytes' | 'unit.kb' | 'unit.mb' | 'unit.gb' | 'unit.tb' | 'unit.pb';

/** Can this column still move that way? The menu greys the ends rather than
 *  offering a button that does nothing. */
export declare function canMoveColumn(id: ColumnId, delta: -1 | 1): boolean;

export declare interface Capabilities {
    /** Document types this build can create. Absent on a server older than the
     *  "New document" feature — hosts must treat that as "offer nothing". */
    newdoc_types?: NewDocType[];
    ffmpeg?: boolean;
    ghostscript?: boolean;
    libreoffice?: boolean;
    onlyoffice_url?: string | null;
    drawio_url?: string | null;
    convert_url?: string | null;
    max_chunk_mb?: number;
    upload_limit_mb?: number;
    /** Longest life a new share link may be given, in days (0 = no ceiling).
     *  Read by the share dialogs so they offer only expiries the server keeps. */
    share_max_ttl_days?: number;
    /** Is the caller a person (`'user'` — a session OR their own API token) or an
     *  integration (`'app'` — a host proxy, a bot, an MCP client)? The explorer
     *  reads it to decide whether to draw the identity-bearing surfaces; see
     *  ExplorerConfig.callerKind. Absent on a server older than the app/user
     *  token split, which is why every reader treats "missing" as a person. */
    caller_kind?: 'user' | 'app';
    /** The address this deployment is reached at — only when it is real (the
     *  operator configured it, or the request came in on a tenant's host).
     *  Read by the connection guides; see `connectionsOrigin`. */
    public_url?: string;
    external?: {
        onlyoffice?: ExternalServiceStatus;
        drawio?: ExternalServiceStatus;
        mermaid?: ExternalServiceStatus;
    };
    /** Whether this installation holds an escrow key for E2E-encrypted folders,
     *  and the public half the browser wraps new folders' master keys to.
     *
     *  Published on purpose. Escrow means the operator can open the folders you
     *  create here without your password, and someone about to create one is
     *  entitled to know that BEFORE they create it. Fixed at install time
     *  (FILEX_INSTALLATION_E2E_ESCROW_KEY), so this answer never changes for a
     *  running installation. */
    e2e_escrow?: {
        enabled: boolean;
        /** Short id of the escrow key (SHA-256(SPKI)[:8], hex). */
        kid?: string;
        alg?: string;
        /** Base64 SPKI. Public material — it can only seal, never open. */
        public_key?: string;
    };
}

export declare function clearResume(store: ResumeStorage | null, key: string): void;

export declare interface ClipboardState {
    mode: 'cut' | 'copy' | null;
    items: FileNode[];
    sourcePath: string | null;
}

/** True when the PERSON has hidden this column — the only reason a column is
 *  ever absent now that width sheds nothing (see `tableLayout`). */
export declare function columnHidden(id: ColumnId): boolean;

/**
 * The columns, in the order the list draws them.
 *
 * ⚠⚠ `name` IS one of them now. It used to be excluded here with the note "it
 * is the flexible column and is never hidden or sized by hand", and that
 * exclusion is precisely the behaviour the owner rejected: as the only
 * `1fr` track Name absorbed whatever every other column gave up, so narrowing
 * Size made Name grow — "küçültme yapınca name kısmı büyüyormuş gibi davranıyor
 * — bu davranış yanlış, istersem name'i de kısabilir olmalıyım." It has a real
 * width like every other column and a handle of its own.
 *
 * It is still not HIDEABLE and not MOVABLE: it carries the tick, the tile and
 * the row's click target, and every file manager pins it first.
 */
export declare type ColumnId = 'name' | 'type' | 'location' | 'owner' | 'modified' | 'size' | 'star';

/**
 * THE COLUMN ORDER — the person's, reconciled with the columns that exist.
 *
 * ⚠⚠ Reconciled, not trusted. A stored order is a list written by an older
 * build, so it can be missing a column added since and can name one removed
 * since. Returning it as-is would make a new column INVISIBLE to everyone who
 * had ever touched the order — a feature that ships and then does not appear
 * for exactly the users engaged enough to have customised something. So:
 * stored entries that still exist keep their place, and anything the stored
 * list never heard of is inserted at its own shipped index.
 *
 * ⚠ ORDER IS GLOBAL, like width and visibility, and unlike the view mode. Two
 * reasons, and the second is the one that would have bitten:
 *   · it is a reading habit ("I want Size next to Name"), not a property of a
 *     folder's contents, which is the line this whole module is drawn on;
 *   · widths are global too, and a per-folder order with global widths would
 *     mean the same six columns at the same six sizes arriving in a different
 *     sequence in every folder — a layout that reads as random rather than as
 *     the person's.
 */
export declare function columnOrder(): ColumnId[];

/**
 * The row's tracks, in shipped order.
 *
 * ⚠ Defaults narrower than the ones they replace (Owner 120 → 104, Modified
 * 170 → 160): those numbers were set at 1440 where there is slack for them,
 * and 170px of Modified is 170px Name does not get at 960.
 *
 * ⚠⚠ There is no `priority` field any more, and its absence is the whole
 * change. It ordered a SHEDDING pass: when the tracks stopped fitting the
 * pane, the least informative column was dropped and the header menu marked it
 * "no room". The owner rejected that outright — "no room demesin, kenara devam
 * eden bir scroll getirsin… genişletildikçe no room olmasın" — so nothing is
 * dropped for want of room ever again. A table wider than its pane scrolls
 * sideways, which is what a table does.
 */
export declare const COLUMNS: readonly ColumnSpec[];

/** True when anything about the columns has been changed by hand — what the
 *  header menu's "Reset columns" is gated on. */
export declare function columnsCustomised(): boolean;

export declare interface ColumnSpec {
    id: ColumnId;
    /** Default width in px. */
    width: number;
    min: number;
    max: number;
    /** Can the person hide it from the header menu? */
    hideable: boolean;
    /** Can the person drag its edge? */
    resizable: boolean;
}

/** This column's width right now — the person's, or the default. */
export declare function columnWidth(id: ColumnId): number;

/**
 * Canonical combo for a keyboard event, or null for a bare modifier
 * press. Meta folds into Ctrl; Shift is dropped for printable symbols
 * because the produced character already encodes it (`?` not `Shift+?`).
 */
export declare function comboFromEvent(e: KeyboardEvent): string | null;

/** Canonical combo → what a human should see. '' stays ''. */
export declare function comboLabel(combo: string): string;

export declare const ConnectionGuideView: DefineComponent<__VLS_Props_21, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_21> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare type ConnectionsApi = ReturnType<typeof useConnections>;

/**
 * The URL prefix the `/api/...` routes hang off.
 *
 * `apiBase: ''` is a legitimate value (the admin SPA is same-origin), so
 * only `undefined`/`null` means "not given" — a falsy check would send the
 * SPA's requests to the wrong place. Legacy embedders configure `endpoint`
 * instead of `apiBase`; the prefix is recovered from it so they are not
 * excluded.
 */
export declare function connectionsBase(config: ExplorerConfig): string;

/**
 * The origin a client program should be pointed at.
 *
 * The instruction pages are only worth anything if they name the real
 * deployment, so this resolves to an absolute address, best evidence first:
 *
 *   1. `publicUrl` — what the SERVER says it is reached at
 *      (`/api/files/capabilities` → `public_url`, published only when the
 *      operator configured it or the request came in on a tenant's own host);
 *   2. the configured apiBase when it is absolute (the desktop app, embeds
 *      that talk to filex directly);
 *   3. the page's own origin (the admin SPA, which the same binary serves).
 *
 * ⚠⚠ The first rung is new and it is the fix. Without it an explorer embedded
 * in ANOTHER app — which proxies `/api` to filex under its own origin, the way
 * work.example.com and fishapp do — printed `https://<that app>/dav/`: an address
 * that reaches the host application, never filex. It also left one guide page
 * speaking with two voices, because its S3 endpoint and SFTP host were always
 * the server's and only the WebDAV / mount lines were the page's.
 */
export declare function connectionsOrigin(config: ExplorerConfig, publicUrl?: string | null): string;

export declare const ConnectionsPanel: DefineComponent<__VLS_Props_19, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (err: {
message: string;
}) => any;
close: () => any;
changed: () => any;
}, string, PublicProps, Readonly<__VLS_Props_19> & Readonly<{
onError?: ((err: {
message: string;
}) => any) | undefined;
onClose?: (() => any) | undefined;
onChanged?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

/** The signed-in account, from `GET /api/auth/me`. */
export declare interface ConnectionsUser {
    id: number;
    email: string;
    display_name?: string;
    role?: string;
}

declare interface ContextAction {
    key: string;
    label: string;
    /**
     * gorunum:v1-icons — OPTIONAL icon override. Rows normally need nothing
     * here: the glyph is looked up by `key` in lib/actionIcons. Set this to
     *   • another icon key, when one action has two faces (`star` / `unstar`);
     *   • any literal string (an emoji), when an embedder wants its own mark —
     *     an unknown name draws no SVG and the string is printed as-is.
     */
    icon?: string;
    danger?: boolean;
    disabled?: boolean;
    /**
     * tasi:m1 — WHY, in one sentence, for a row that is greyed out.
     *
     * ⚠ A disabled control has to explain itself or it is indistinguishable from
     * a broken one. Sharing works on one item at a time, so "Paylaş / İzinler"
     * greys out above a multi-selection — grey with a reason reads as a rule,
     * grey without one reads as a bug, and HIDING it (which is what this row did
     * until 2026-09-13) reads as the feature not existing.
     *
     * Rendered as the native `title` on both surfaces. Absent leaves the
     * tooltip each surface already builds — the label plus its shortcut in the
     * selection bar, nothing in the menu.
     */
    title?: string;
    hidden?: boolean;
    divider?: boolean;
    /**
     * tus:t1 — registry action id whose key this row should print. Optional:
     * rows whose `key` already matches the registry (rename, delete, copy…)
     * are resolved from the shared map and need nothing here.
     */
    shortcutId?: string;
}

export declare interface CreatedFolder {
    marker: E2eMarker;
    /** The folder master key, ready for encryptFile/decryptFile. */
    fmk: CryptoKey;
    /** Show this ONCE. filex never stores it and can never show it again. */
    recoveryKey: string;
}

/**
 * Create a v2 encrypted folder: random FMK, wrapped under the password KEK,
 * under a freshly minted user recovery key, and — when the installation has
 * escrow enabled — to the escrow public key.
 */
export declare function createEncryptedFolder(password: string, opts?: CreateFolderOptions): Promise<CreatedFolder>;

export declare interface CreateFolderOptions {
    iterations?: number;
    /** Base64 SPKI of the installation escrow key, when escrow is enabled. */
    escrowPublicKey?: string | null;
}

/**
 * Tiny per-explorer key ring: encrypted-folder root (wire path) → FMK.
 * Lives ONLY in memory — "Lock" drops the entry, a reload drops all.
 */
export declare function createKeyRing(): {
    get(root: string): CryptoKey | undefined;
    set(root: string, fmk: CryptoKey): void;
    /** Drop one folder's key ("Lock"). */
    lock(root: string): void;
    has(root: string): boolean;
    clear(): void;
};

/**
 * Create a v1 folder marker — the pre-0.31 format, with NO recovery of any
 * kind.
 *
 * @deprecated Use `createEncryptedFolder`. Kept exported, and kept producing
 * a genuine v1 marker, so an embedder pinned to the old API keeps creating
 * folders this build can still open rather than half-formed v2 ones.
 */
export declare function createMarker(password: string, iterations?: number): Promise<{
    marker: E2eMarker;
    kek: CryptoKey;
}>;

/** Every step from the storage root down to `p`, for a clickable breadcrumb. */
export declare function crumbsOfWire(p: string): Array<{
    label: string;
    path: string;
}>;

/** One rung: a stable id to compare runs by, and the words to draw. */
export declare interface DateBucket {
    id: string;
    label: string;
}

/**
 * THE LADDER.
 *
 * Today · Yesterday · This Week · This Month · then one rung per month,
 * named ("September 2026"). Undated rows land in "No date", which the sort
 * already parks at the end in both directions (`lib/sortOrder.byActiveKey`).
 *
 * Measured against the reference the owner pointed at — filex.blipnova.com,
 * 2026-09-13, the `/recent` page, which is the only surface there that groups.
 * Its ladder is `Today · Yesterday · <that day's date>`: one heading per
 * calendar day for ever, taken from the browser's own clock. Ours keeps its
 * first two rungs verbatim and then collapses, deliberately:
 *
 *   - a heading per day is not a grouping once a listing is long — a folder
 *     touched file-by-file over a month draws thirty headings over thirty
 *     single rows;
 *   - the owner's own words name the rungs we keep: "son bir hafta, dün,
 *     bugün, bu ay içinde vb." (last week, yesterday, today, within this
 *     month, and so on);
 *   - and the reference reads the DEVICE's calendar, which is the bug
 *     `lib/timezone` exists to have fixed here.
 *
 * ⚠ "This Week" is the six days before yesterday (`day > today - 7`), NOT a
 * calendar week: a Monday listing with a calendar rule would put Sunday —
 * eighteen hours ago — under a month heading.
 *
 * ⚠ A stamp in the future reads best as "today". Clock skew between a storage
 * and the reader is ordinary, and "September 2027" over the file somebody just
 * saved is worse than a day's imprecision.
 */
export declare function dateBucketFor(d: Date | null, l: DateGroupLabels): DateBucket;

/**
 * The grouping, in the two shapes the three views need.
 *
 * `runs` is for a view that renders segment by segment (the list, whose rows
 * are already nested under a heading element). `headingBefore` is for a view
 * that renders one flat sequence of cards and inserts a full-width heading
 * item in front of the card that starts a run (the grid and the gallery).
 *
 * ⚠ They are two readings of ONE pass, not two implementations: the map is
 * built from the runs. A view that used its own "did the bucket change since
 * the previous card" test would be the second copy this module exists to
 * prevent.
 */
export declare interface DateGrouping<T> {
    /** Mirrors the `active` that was asked for — views branch on it. */
    active: boolean;
    runs: DateRun<T>[];
    /** The heading to draw immediately before this item, or null. */
    headingBefore: (item: T) => string | null;
}

/**
 * What a view lends this module so the headings speak its language and read
 * its clock. All three come straight off `useLocale(...)`.
 */
export declare interface DateGroupLabels {
    t: (key: string) => string;
    /** "September 2026", in the viewer's locale and zone. */
    formatMonthYear: (value: number | Date | undefined | null) => string;
    /** `YYYY-MM` in the viewer's zone — a bucket id, not a label. */
    zonedYearMonth: (value: number | Date | undefined | null) => string;
}

declare interface DateGroupOptions<T> {
    /** `groupingActive(...)`. False → one unlabelled run holding everything. */
    active: boolean;
    /** The instant this item is filed under, or null for "no date". */
    dateOf: (item: T) => Date | null;
    /**
     * Items that are NOT filed under a date — return the run they belong to, or
     * null to bucket them by date like everything else.
     *
     * ⚠ This is how "folders first" survives a date sort. Folders are given a
     * run of their own at the top rather than floating to the top of each
     * bucket, because floating would split a bucket in two and draw "Today"
     * twice — once over the folders, once over the files. A folder has no
     * meaningful modification date to file under anyway. The list uses it for
     * its pinned storage rows as well.
     */
    aside?: (item: T) => AsideRun | null;
    labels: DateGroupLabels;
}

/** A contiguous run of items that share a heading. `label: null` = no heading. */
export declare interface DateRun<T> {
    id: string;
    label: string | null;
    items: T[];
}

/**
 * Record that this folder's owner was offered an escrow slot and declined.
 *
 * A refusal is a decision, not a delay: without this the offer would come
 * back on every single unlock, which is how people learn to click past
 * security dialogs without reading them. Nothing about the folder's keys
 * changes — the only effect is that filex stops asking.
 *
 * Reversible by `addEscrowSlot`, which is the way back for somebody who
 * says no today and changes their mind next month.
 */
export declare function declineEscrowSlot(marker: E2eMarker, when: string): E2eMarker;

/**
 * Decrypt a 'filexe2e' blob with the folder master key. Throws
 * E2eDecryptError on a wrong key / tampered data, and a plain Error when the
 * header is not an e2e file at all.
 */
export declare function decryptFile(fmk: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;

/**
 * Default timeout. ⚠ Measured, not guessed: a browser takes ~5 s to give up on
 * a DNS name that does not exist (`http://onlyoffice`), and that case must
 * report `unreachable`, not `timeout`. 10 s leaves room and still bounds a
 * black hole.
 */
export declare const DEFAULT_PROBE_TIMEOUT_MS = 10000;

export declare const DEFAULT_THEME_ID = "default";

/** The one this package draws when nobody says otherwise. */
export declare const DEFAULT_UI_PROFILE: UiProfile;

/** The default backing store, or null where the platform has none. Reading
 *  localStorage throws in a partitioned/blocked context, so the probe is a real
 *  try, not a typeof check. */
export declare function defaultResumeStorage(): ResumeStorage | null;

declare type Density = 'comfortable' | 'compact';

/**
 * Derive the folder KEK from a password. Returns a NON-extractable
 * AES-256-GCM CryptoKey — it can encrypt/decrypt but never be exported,
 * so even a same-origin script can't read the raw key material back.
 */
export declare function deriveKek(password: string, salt: Uint8Array, iterations: number): Promise<CryptoKey>;

export declare const DestinationPickerModal: DefineComponent<__VLS_Props_7, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
pick: (path: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_7> & Readonly<{
onClose?: (() => any) | undefined;
onPick?: ((path: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** One row in the picker's list. */
export declare interface DestinationRow {
    /** Wire path of the folder. */
    path: string;
    /** What to show — the folder's own name. */
    label: string;
    /** May the caller write into it? Drives the disabled Choose button. */
    writable: boolean;
    /** Set when this row is one of the folders being moved, or inside one. */
    blocked: 'self' | 'descendant' | null;
}

/**
 * Turn a listing into rows.
 *
 * ⚠ An unwritable folder is LISTED and stays OPENABLE. The grant that allows
 * writing may live on a subfolder, so hiding the parent would make the
 * destination unreachable; hiding it also tells the user their folder is gone
 * rather than that they may not write into it. Same rule NewDocumentModal
 * settled on.
 *
 * ⚠ A blocked folder (the one being moved, or inside it) is also listed rather
 * than hidden: seeing it greyed out with a reason is how a person understands
 * the refusal. It is not openable, because everything under it is blocked too
 * and walking into a dead end is not navigation.
 */
export declare function destinationRows(files: FileNode[] | undefined, moving?: string[]): DestinationRow[];

/**
 * The browser's preference, or `en`.
 *
 * ⚠ Guarded for a non-browser runtime: this package is imported by SSR and by
 * unit tests under Node, where `navigator` is absent — and an exception here
 * would take down the whole explorer over a language choice.
 */
export declare function detectLocale(): LocaleCode;

/** The zone this browser is in right now, asked fresh every time. */
export declare function deviceTimeZone(): string;

/**
 * koru:k1 — the RBAC level of the folder this pane is in, '' when ACL is not
 * enforced (or when the host drives the rows: it answered the request, so it
 * is holding the `perm` this pane never saw).
 */
declare function dirPerm(): string;

/**
 * How long a download iframe is left in the document.
 *
 * It only has to outlive the moment the browser reads the response headers and
 * hands the body to its download manager; the transfer itself continues after
 * the element is gone. Sixty seconds is slack for a storage that takes a while
 * to produce the first byte, and is short enough that a session of repeated
 * downloads does not accumulate frames.
 */
export declare const DOWNLOAD_FRAME_TTL_MS = 60000;

/**
 * Mint an archive for `paths` and start downloading it.
 *
 * Resolves with the ticket once the download has been STARTED — not once it has
 * finished, which the page cannot observe. A caller that wants to say "12 files"
 * in a toast reads it off the returned ticket.
 */
export declare function downloadArchive(api: Pick<FileApi, 'jsonFetch' | 'endpoints'>, paths: string[], opts?: {
    name?: string;
    doc?: Document;
}): Promise<ArchiveTicket>;

declare interface DriveFilters {
    type: TypeFilter;
    modified: ModifiedFilter;
    size: SizeFilter;
    /**
     * gorunum:v1 — "Filter in this folder…", the input the filter row carries
     * beside the chips. A substring of the NAME, matched over the rows in hand.
     *
     * ⚠ Not a second search box. The header field runs `action=search` on the
     * server and REPLACES the listing with hits (`isSearchResult`, results carry
     * their parent path and can come from subfolders); this one never leaves the
     * folder you are looking at and never issues a request — it narrows what is
     * already on screen, the same rows the chips narrow, which is why it belongs
     * to the same model and not to `searchQuery`.
     *
     * Optional so every existing `{ type, modified, size }` literal — embedders
     * included — still type-checks and behaves exactly as before.
     */
    name?: string;
    /** Anchor for `modified: 'around'`. `YYYY-MM-DD` or `YYYY-MM-DDTHH:mm`,
     *  read as LOCAL time (a date alone means that day's 00:00 local). */
    aroundDate?: string;
    /** Half-width of the `around` window. */
    aroundSpan?: AroundSpan;
    /** Inclusive floor for `size: 'range'`, in BYTES. null = open-ended. */
    sizeMin?: number | null;
    /** Inclusive ceiling for `size: 'range'`, in BYTES. null = open-ended. */
    sizeMax?: number | null;
    /** `here` keeps only rows under `pathBase`; `skip` keeps only rows outside it. */
    pathMode?: PathMode;
    /**
     * Who the row belongs to. Optional, under the same contract as `name` and
     * the advanced-search three: every existing `{ type, modified, size }`
     * literal still type-checks and behaves exactly as before.
     */
    people?: PeopleFilter;
    /** Adapter-qualified folder the path choice is measured against, e.g.
     *  `qldemo://Documents`. Captured when the dialog opens, because a search
     *  rebases the explorer to the storage root and the folder the user meant
     *  would otherwise be gone by the time the filter runs. */
    pathBase?: string;
}

/** The drives level: one row per storage, each its own root. */
export declare function driveRows(storages: string[] | undefined, moving?: string[]): DestinationRow[];

/**
 * The browser's top level: the list of drives rather than a folder.
 *
 * It cannot collide with a real destination because every wire path contains
 * `://` and this string does not. (The same sentinel and the same reasoning as
 * NewDocumentModal's private browser, which this module is meant to replace.)
 */
export declare const DRIVES = "@@drives";

export declare const E2E_DEFAULT_ITERATIONS = 600000;

/** The only escrow algorithm this version understands. */
export declare const E2E_ESCROW_ALG = "RSA-OAEP-256";

export declare const E2E_MAGIC = "filexe2e";

/**
 * e2ecrypto — client-side crypto for E2E-encrypted folders (wiring:e2).
 *
 * WebCrypto ONLY — zero dependencies. Design doc: docs/E2E-ENCRYPTION.md.
 *
 * ── Scheme ────────────────────────────────────────────────────────────
 *
 * Every encrypted file wraps its own random DEK under ONE key, the folder
 * master key (FMK), and stores the wrapped copy in its own 97-byte header.
 * The FMK is what a "key slot" in the folder marker hands back:
 *
 *   password ─PBKDF2-SHA256(600k, 16B salt)─▶ KEK ─┐
 *   recovery key ─HKDF-SHA256(16B salt)─▶ RKEK ────┼─▶ unwraps the FMK
 *   escrow private key ─RSA-OAEP-256───────────────┘
 *                                                   │
 *   per-file random 32B DEK ◀── AES-GCM-wrapped by the FMK, in the header
 *
 * Adding a recovery path therefore costs one more wrapped copy of a single
 * 32-byte key in the marker — not a re-encrypt of anything. The file format
 * below is UNCHANGED from v1 and stays that way; only the marker grew.
 *
 * ── Marker versions ───────────────────────────────────────────────────
 *
 * v1 (shipped up to 0.30.1) has no slots: the DEK is wrapped directly by
 * the password KEK. Read that as "the FMK *is* the KEK". Such folders keep
 * opening with nothing but their password, forever — the v1 read path is a
 * first-class path here, not a migration shim.
 *
 * v2 adds the slots. It comes in two flavours, told apart by `fmk`:
 *   - `fmk: 'wrapped'` — a fresh random FMK, held in `fmk_pw` wrapped under
 *     the password KEK. Every folder created from 0.31 on.
 *   - `fmk: 'kek'`     — a v1 folder that was given recovery keys in place.
 *     Its files were already wrapped under the KEK and are not rewritten, so
 *     the FMK stays defined as "the password-derived KEK" and the recovery
 *     slots wrap those raw 32 bytes. The password path is byte-identical to
 *     v1; only the extra slots are new.
 *
 * ── Invariants ────────────────────────────────────────────────────────
 *
 *   - No key, password or recovery key is ever stored, logged or sent to a
 *     server. The FMK lives in an in-memory key ring and dies with the tab.
 *   - `deriveKek` imports non-extractable. Raw KEK bytes are produced ONLY
 *     by `deriveKekBits`, only for a marker whose FMK *is* the KEK
 *     (`upgradeMarkerV1`, and `addEscrowSlot` on a folder it produced), and
 *     only long enough to wrap them into a slot.
 *   - A folder created while escrow was off carries no escrow slot, so the
 *     escrow key cannot open it, and nothing the OPERATOR does changes
 *     that — not enabling escrow, not adopting it, not any admin action or
 *     future version. That is arithmetic, not policy: adding a slot needs
 *     the folder master key, and the server has never held a credential
 *     that produces one.
 *   - The folder's OWNER can, from inside, with the password:
 *     `addEscrowSlot`. That is the only door, it opens from one side only,
 *     and it is the reason `escrowAvailability` says "not as things stand"
 *     rather than "never".
 *
 * File layout ('filexe2e' magic, fixed 97-byte header) — UNCHANGED in v2:
 *   [0..8)   magic  "filexe2e"
 *   [8]      version 0x01
 *   [9..21)  wrapIV  (12B)  — GCM IV of the DEK wrap
 *   [21..69) wrappedDEK (48B = 32B DEK + 16B GCM tag), wrapped by the FMK
 *   [69..81) dataIV  (12B)  — GCM IV of the content
 *   [81..97) reserved (zeros; v2 chunking/metadata)
 *   [97..)   ciphertext (content + 16B GCM tag)
 */
export declare const E2E_MARKER_NAME = ".filex-e2e.json";

/** Marker schema version written by this build. v1 markers still read. */
export declare const E2E_MARKER_VERSION = 2;

/** MVP single-shot in-memory ceiling — larger uploads are refused with a warning. */
export declare const E2E_MAX_FILE_BYTES: number;

export declare const E2E_MIN_PASSWORD_LEN = 8;

/** Entropy of a user recovery key: 20 bytes = 160 bits = exactly 32 base32 chars. */
export declare const E2E_RECOVERY_KEY_BYTES = 20;

/** File-header version byte. Unchanged by the recovery work. */
export declare const E2E_VERSION = 1;

/** Thrown on wrong password / corrupted ciphertext (GCM tag mismatch). */
export declare class E2eDecryptError extends Error {
    constructor(msg?: string);
}

/** Escrow slot: the FMK encrypted to the installation's escrow public key. */
export declare interface E2eEscrowSlot {
    /** First 8 bytes of SHA-256(SPKI), hex — names WHICH escrow key this is. */
    kid: string;
    alg: string;
    blob: string;
}

/** How the folder master key is obtained from the password slot. */
export declare type E2eFmkMode = 'kek' | 'wrapped';

export declare type E2eKeyRing = ReturnType<typeof createKeyRing>;

export declare interface E2eMarker {
    v: number;
    salt: string;
    iter: number;
    verify: string;
    /** v2 only. Absent on a v1 marker, where the FMK is implicitly the KEK. */
    fmk?: E2eFmkMode;
    /** v2 + fmk==='wrapped' only: base64 12B IV || AES-GCM(KEK, FMK). */
    fmk_pw?: string;
    /** v2 only, optional: the user recovery key slot. */
    rk?: E2eRecoverySlot;
    /** v2 only, optional: the operator escrow slot. */
    esc?: E2eEscrowSlot;
    /**
     * v2 only, optional: an ISO timestamp recording that this folder's owner
     * was OFFERED an escrow slot and said no.
     *
     * It lives in the marker rather than in browser storage because the unit
     * of the decision is the FOLDER, not the device: the same person opening
     * the folder from their phone must not be asked again, and a decision
     * that vanished when someone cleared their site data would be no decision
     * at all. It travels with the folder through a move, a backup and a
     * restore, for the same reason the key slots do.
     *
     * It holds no key material and hides nothing from the operator — it is a
     * record of an answer, and its only effect is that filex stops asking.
     * `addEscrowSlot` clears it, so a decline is reversible by the one person
     * who can reverse it.
     */
    esc_declined?: string;
}

/** User-recovery-key slot: HKDF salt + the FMK wrapped under the derived key. */
export declare interface E2eRecoverySlot {
    salt: string;
    blob: string;
}

export declare const E2eRecoveryUnlockModal: DefineComponent<__VLS_Props_18, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
submit: (payload: {
mode: "recovery" | "escrow";
value: string;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_18> & Readonly<{
onClose?: (() => any) | undefined;
onSubmit?: ((payload: {
mode: "recovery" | "escrow";
value: string;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** Current combo for an action ('' = unbound). */
export declare function effectiveCombo(id: string): string;

/** English UI strings. */
export declare const en: Record<string, string>;

export declare const EncryptedFolderModal: DefineComponent<__VLS_Props_16, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
submit: (payload: {
name: string;
password: string;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_16> & Readonly<{
onClose?: (() => any) | undefined;
onSubmit?: ((payload: {
name: string;
password: string;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/**
 * Encrypt `content` under the folder master key: mints a fresh DEK, encrypts
 * the content one-shot, wraps the DEK with the FMK and prepends the fixed
 * 'filexe2e' header. Throws when content exceeds E2E_MAX_FILE_BYTES.
 *
 * `fmk` is the key an unlock returned. On a v1 folder that is the password
 * KEK, which is why v1 files keep working untouched.
 */
export declare function encryptFile(fmk: CryptoKey, content: ArrayBuffer): Promise<ArrayBuffer>;

/**
 * Resolved endpoint map. `useFileApi` derives this once on construction
 * — components never need to think about config/apiBase precedence.
 */
export declare interface EndpointMap {
    manager: string;
    /**
     * Staged upload — the chunked, resumable, driver-agnostic path every client
     * speaks (docs/UPLOADS.md). The per-upload routes (`PUT/GET/DELETE {id}`,
     * `POST {id}/commit`) are derived from it by stripping `/begin`, so one
     * override moves the whole protocol.
     */
    uploadBegin: string | null;
    /** Legacy S3-presigned chunked upload. Still served by the backend for
     *  older embedders; nothing in this package calls it. */
    uploadInit: string | null;
    uploadFinalize: string | null;
    uploadAbort: string | null;
    shareCreate: string | null;
    shareList: string | null;
    shareDelete: string | null;
    limits: string | null;
    capabilities: string | null;
    archiveList: string | null;
    archiveExtract: string | null;
    archiveAdd: string | null;
    copy: string | null;
    moveAsync: string | null;
    deleteAsync: string | null;
    opsList: string | null;
    opsShow: string | null;
    onlyOfficeConfig: string | null;
    saveText: string | null;
    restore: string | null;
    trashList: string | null;
    trashRestore: string | null;
    e2eEscrowChallenge: string | null;
    e2eEscrowUsed: string | null;
}

export declare function ensureHighlight(): Promise<unknown | null>;

/**
 * Resolve Monaco. If preload hasn't been kicked off yet, this triggers
 * it (and pays the load cost on the spot). Returns `null` when the
 * package isn't installed.
 */
export declare function ensureMonaco(): Promise<unknown | null>;

/**
 * Why the escrow door is, or is not, on offer for this folder.
 *
 *   'off'        this installation has no escrow key at all.
 *   'available'  the folder is sealed to THIS installation's escrow key.
 *   'predates'   the installation has an escrow key, and this folder has no
 *                escrow slot: it was created before escrow existed here.
 *   'other-key'  the folder carries an escrow slot sealed to a DIFFERENT
 *                key id — it came from another installation, via a restore
 *                or a copied data directory.
 *
 * ⚠ 'predates' exists because escrow can be ADOPTED by an installation
 * that already has folders (FILEX_INSTALLATION_E2E_ESCROW_ADOPT), and
 * adoption is not retroactive: the folder's master key was wrapped to its
 * recovery paths when the folder was created. Before this distinction
 * existed the dialog simply showed no Escrow tab, which is true but says
 * nothing — an admin who knows escrow is on reads a missing tab as a bug,
 * tries the key anyway, and learns the real answer from a failure. The UI
 * has to say it instead.
 *
 * ⚠⚠ 'predates' means "not as things stand", NOT "never". The folder's
 * owner can add a slot from inside with the password (`addEscrowSlot`,
 * offered at unlock). Any wording built on this state has to leave that
 * door visible, or it tells an operator their escrow key can never reach a
 * folder whose owner could hand it over this afternoon.
 *
 * ⚠ 'other-key' was a quieter lie: the dialog labelled the escrow field
 * with the INSTALLATION's key id whatever the folder's slot said, so a
 * folder restored from another install looked openable by the key the
 * operator has, and was not.
 */
export declare type EscrowAvailability = 'off' | 'available' | 'predates' | 'other-key';

export declare function escrowAvailability(m: E2eMarker | null, installationKid: string | null | undefined): EscrowAvailability;

/**
 * Stable short name for an escrow key: first 8 bytes of SHA-256(SPKI), hex.
 * Written into every escrow slot so a marker says WHICH key opens it, and so
 * the UI can tell "this server's escrow key" from "some other one".
 */
export declare function escrowKeyId(spkiB64: string): Promise<string>;

/**
 * Whether this folder's owner should be offered an escrow slot, and whether
 * they have already answered.
 *
 *   'n/a'       nothing to offer: the installation has no escrow key, the
 *               folder already has a slot, or the marker is v1 (whose path
 *               is `upgradeMarkerV1`).
 *   'offer'     the offer applies and no answer has been recorded.
 *   'declined'  the offer applies and the owner said no. Do not ask again;
 *               leave a way back.
 *
 * ⚠ This deliberately does NOT look at whether the folder is unlocked. That
 * is the caller's business, and it matters: the offer may only be shown
 * after an unlock actually succeeded, because accepting needs the password
 * and because asking someone who cannot open the folder to give away a key
 * to it is asking the wrong person.
 */
export declare type EscrowOfferState = 'n/a' | 'offer' | 'declined';

export declare function escrowOfferState(m: E2eMarker | null, installationKid: string | null | undefined): EscrowOfferState;

/**
 * Does this event fire the given registry action? For overlays that
 * handle their own keys (the quick-look peek) rather than going through
 * the global binder — without this they keep answering to the DEFAULT
 * key after the user has remapped the action.
 */
export declare function eventMatchesShortcut(e: KeyboardEvent, id: string): boolean;

export declare interface ExplorerConfig {
    /**
     * Modern shorthand: URL prefix for the standard /api/files/* layout.
     * Example: `https://files.example.com` → `${apiBase}/api/files/manager`,
     * `${apiBase}/api/files/upload/init`, etc. Any explicit endpoint*
     * field below overrides the derived URL.
     */
    apiBase?: string;
    /** Legacy main endpoint (Vuefinder-compat: GET/POST `?q=…`). */
    endpoint?: string;
    /** Staged upload entry point; the `{id}` routes hang off it. */
    uploadBegin?: string;
    uploadInit?: string;
    uploadFinalize?: string;
    uploadAbort?: string;
    shareCreate?: string;
    shareList?: string;
    /** DELETE template; `{uuid}` placeholder is replaced at call time. */
    shareDelete?: string;
    limits?: string;
    capabilities?: string;
    archiveList?: string;
    archiveExtract?: string;
    archiveAdd?: string;
    /** Recursive S3-side copy with "-copy" collision suffix (async). */
    copy?: string;
    /** Async move endpoint — returns {op}, client polls /opsList. */
    moveAsync?: string;
    /** Async delete endpoint — returns {op}, client polls /opsList. */
    deleteAsync?: string;
    /** Pending ops list endpoint (poll target). */
    opsList?: string;
    /** Single op show endpoint — `{id}` placeholder. */
    opsShow?: string;
    /**
     * OnlyOffice config endpoint. Backend POST returns
     * `{ config, documentServerUrl }` where `config` is a JWT-signed
     * DocEditor config. PreviewModal mounts the editor against this
     * when the user opens an office file with mode=edit.
     */
    onlyOfficeConfig?: string;
    /**
     * Standalone editor page base — when set, "Open" on an office file
     * opens `${openPageBase}?path=...&mode=edit` in a new tab instead
     * of the modal preview.
     */
    openPageBase?: string;
    /**
     * Plain-text save endpoint — POST `{path, content}`. When set, code
     * preview gains an editable mode + save button. Falsy = read-only.
     */
    saveText?: string;
    /**
     * Trash restore endpoint — `POST {source: string[]}`. When set, a
     * "Geri Getir" action shows up in `.trash/` listings.
     */
    restore?: string;
    /** filex trash listing endpoint — `GET → { entries: TrashEntry[] }`. */
    trashList?: string;
    /** filex trash restore endpoint — `POST { node_id }`. */
    trashRestore?: string;
    /** E2E escrow proof-of-possession — `POST { path } → { id, challenge }`. */
    e2eEscrowChallenge?: string;
    /** E2E escrow use report — `POST { path, id, nonce }`. */
    e2eEscrowUsed?: string;
    /**
     * Public share base URL.
     *
     * @deprecated IGNORED — declared, never read. Share URLs are used exactly as
     * the server returns them (`share.url`), which is what makes a link work
     * behind a reverse proxy; a client-side base could only disagree with it.
     * Set `FILEX_PUBLIC_URL` on the server instead.
     */
    shareBase?: string;
    /** Auth strategy (see AuthConfig). */
    auth?: AuthConfig;
    /** Show the virtual `.trash/` entry in the root listing. */
    trashVisible?: boolean;
    /** UI dil kodu */
    locale?: LocaleCode;
    /**
     * The clock this embed's visitors read dates on by default — an IANA id,
     * `'Asia/Tokyo'`, `'Europe/Istanbul'`, `'UTC'`.
     *
     * Only which clock an instant is READ on changes; the instant itself does
     * not. Unset, a visitor sees the zone of the account behind the credential
     * when that credential is a person's, and otherwise their browser's own.
     *
     * ⚠ A default, not a lock. A visitor who picks a zone in the explorer's own
     * "⋯" → Time zone keeps their pick, in their browser. The whole order, and
     * why it is that order, is `TIME_ZONE_TIERS` in `lib/timezone`. An id the
     * browser does not accept is ignored rather than guessed at.
     */
    timeZone?: string;
    /** OnlyOffice iframe base (e.g. `https://docs.example.com`). */
    onlyOfficeBase?: string;
    /** Drawio iframe base. */
    drawioBase?: string;
    /** Universal converter (p2r3/convert fork) iframe base, e.g. `https://fm.example.com/convert`. */
    convertBase?: string;
    /**
     * Drawio embed URL (full URL to the embed endpoint). Defaults to
     * `https://embed.diagrams.net`. The DrawioViewer iframes this with
     * `?embed=1&proto=json` postMessage handshake to load + save XML.
     */
    drawioUrl?: string;
    /**
     * Optional URL where serialized PDF annotations / form data is
     * persisted. POST `{ path, base64 }` — the rich PdfViewer uses
     * `pdf.saveDocument()` and forwards the saved bytes here when the
     * user clicks the save annotation button.
     */
    pdfSaveUrl?: string;
    /**
     * Override the pdf.js worker URL. Defaults to a CDN copy matching
     * the version pdfjs-dist resolves to at runtime — hosts can pin
     * their own self-hosted worker for CSP-strict environments.
     */
    pdfWorkerUrl?: string;
    /**
     * Standalone full-screen viewer route. The PreviewModal toolbar's
     * "Open in new tab" button navigates to
     * `${viewerBaseUrl}?path=…&storage=…&type=…`. The consumer wires
     * that route to mount the same viewer fullscreen (admin UI / fishapp
     * embed). Defaults to `/files/viewer`.
     */
    viewerBaseUrl?: string;
    /**
     * Upload chunk size (bytes). Default 8 MB — the server's default too, so
     * "large enough to chunk" means the same thing on both ends. The value the
     * server returns from `begin` is binding; this is what the client asks for
     * and the threshold above which a file goes on the staged path at all.
     */
    chunkSize?: number;
    /**
     * @deprecated Ignored since the move to the staged protocol. Chunks are sent
     * sequentially because `offset` — the resume point — is the contiguous run
     * from part 1; parallel parts would leave holes that a resumed upload has to
     * re-send anyway.
     */
    parallelChunks?: number;
    /** Theme. */
    theme?: ThemeMode;
    /**
     * When the tab strip is on screen. Default `'always'`.
     *
     * ⚠⚠ The default is the SAME on every surface on purpose. This package is
     * the reason the desktop app, the web explorer and the embeds are one
     * product; shipping a strip that appears in one of them and not the others
     * turns it back into three. 0.16.0 defaulted this to `'auto'` and opted the
     * desktop app in — so tabs were permanent in the app and came and went on
     * the web, which is exactly the split the shared package exists to prevent.
     *
     * `'auto'` remains as a deliberate opt-OUT for an embed too short to spend
     * a row on: it shows the strip only once a second tab exists.
     */
    tabStrip?: 'auto' | 'always';
    /**
     * Initial path (storage-prefix included: `local://`). Default: root.
     *
     * gorunum:v3-shell — a VIEW is addressable here too, by its sentinel:
     * `'.home'` opens the overview (storages · recent · starred), and
     * `'.recent'` / `'.starred'` / `'.shared'` / `'.trash'` / `'.tag~invoices'`
     * open theirs. That is how our own `/home` route opens Home without a second
     * mechanism — the sentinels are the same strings the address-bar hash, the
     * tab strip and a restored session already speak (lib/listing
     * VIRTUAL_SEGMENTS), so there is one answer to "where does this explorer
     * start" rather than a path answer and a view answer that can disagree.
     *
     * ⚠ A sentinel this build does not know keeps going to the backend as a
     * folder name, so a host cannot invent views by passing strings.
     */
    initialPath?: string;
    /**
     * Confine the explorer to this folder (qualified: `main://projeler/acme`).
     * The UI opens here, hides the multi-storage drives root, and blocks
     * navigation above it. SECURITY IS NOT THIS — enforce it server-side with an
     * X-Filex-Root header / root-scoped API token; this is the clean-embed UX.
     */
    rootPath?: string;
    /**
     * gorunum:v3-shell — the product mark at the far left of the top bar: the
     * wordmark beside it, and an image for the mark itself.
     *
     * ⚠⚠ This exists because a `<slot>` IS NOT REACHABLE from a host that mounts
     * `<filex-explorer>`, and that is not a bug anybody can fix in a line.
     * Measured, 2026-09-13, in a real browser with Vue's own
     * `defineCustomElement`: a `<span slot="brand">` placed inside the element
     * leaves `Object.keys(slots)` EMPTY in the element's `setup` — with the
     * wrapper forwarding slots, without it, when the node is added after mount,
     * and with `shadowRoot: true` as well. Vue projects light DOM into a custom
     * element only through a NATIVE `<slot>` element inside a shadow root, which
     * this package cannot have: its entire look is one global stylesheet
     * (`styles/base.css`), and a shadow root would leave every embed unstyled.
     *
     * So the slot is for hosts that mount the Vue SFC (our admin app does, and
     * its `#brand` still wins when it is filled); this is for everybody else —
     * and "everybody else" includes OUR OWN DESKTOP APP, which mounts the web
     * component. A logo the web app has and the desktop app silently lacks is
     * exactly the one-surface split this package exists to prevent.
     *
     * ⚠ An `<img src>`, not markup. The mark is drawn from a URL — a file, or a
     * `data:image/svg+xml;base64,…` URI for an inline logo — so a host never
     * hands this package a string to inject. There is no `v-html` on the path.
     *
     * ⚠ Both halves are optional and independent: a name with no mark renders
     * the wordmark alone, a mark with no name renders the glyph alone, and
     * neither renders nothing at all (the collapse control still sits there).
     */
    brand?: {
        /** Wordmark text, e.g. `'filex'`. Printed verbatim, never translated. */
        name?: string;
        /** URL of the mark: a path, an absolute URL, or a `data:` URI. */
        markUrl?: string;
    };
    /**
     * Whether the info-panel (inspector) toggle is shown in the toolbar.
     * Default true. The inspector itself stays reachable from the context menu.
     */
    showInfoPanel?: boolean;
    /**
     * How much of the explorer to put on screen. A REDUCTION, and only that.
     *
     *   'standard' (default) — everything: the tab strip, the split pane and all
     *                          three view modes, on top of the shell below.
     *   'simple'             — one pane, one folder, list and grid only. The tab
     *                          strip and the split pane are off, the gallery view
     *                          mode is hidden, and the "How to connect" /
     *                          "API keys" entries default to off.
     *
     * There is no third value and no alias. ⚠ Anything else that arrives here —
     * a typo, or the `'drive'` profile that was REMOVED after v0.40.0 —
     * resolves to `'standard'` and logs one console line naming it
     * (`lib/uiProfile.resolveUiProfile`, which explains why that direction and
     * not the other). **If you passed `'drive'`, pass `'simple'`.**
     *
     * ⚠⚠ IT DOES NOT DECIDE THE LOOK, and that is the whole of this option.
     * The header with its one wide search field, the "+ New" menu, the filter
     * row, the Folders/Files sections, the Details/Activity tabs and the storage
     * line USED to be gated behind a profile. They are what filex is now — the
     * admin panel, the desktop app and every `<filex-explorer>` embed draw them,
     * with no string passed. Owner's decision, 2026-09-12, verbatim (translated
     * from Turkish): "their app and our app will be one to one. The admin gets
     * one extra button, nothing else. The things we have over them — tabs, split
     * pane, theme choice, icon choice — stay."
     *
     * Why the reduction exists at all (GitHub #14): the reporter's users are not
     * in IT and read split panes, tabs and mount instructions as a file manager
     * they would have to relearn. The answer was NOT a second UI — one explorer,
     * configured, so a fix lands in one place for every surface that mounts this
     * package.
     *
     * ⚠ It does not gate the navigation panel. The panel ships in every profile,
     * for administrators too; only a viewer's own collapse choice moves it, and
     * that is a per-viewer preference, not a policy.
     */
    uiProfile?: UiProfile;
    /**
     * Render the navigation panel (Upload · Recent / Starred / Shared with me /
     * Trash · the storage list). Collapsible to an icon rail by the viewer, whose
     * choice is remembered per browser.
     *
     * Default: ON — everywhere, including the desktop app and every embed. This
     * package is the reason those are one product; a panel that appeared in the
     * web app and nowhere else would turn it back into three (0.16.0 did exactly
     * that with `tabStrip` and it had to be undone).
     *
     * ⚠ ONE exception, and it is about `rootPath`, not about who is embedding: a
     * confined embed has no storage list to show, and its views would list files
     * from OUTSIDE the folder the embed was confined to. So `rootPath` flips the
     * default to off. Setting `sideNav: true` alongside `rootPath` still wins —
     * the panel is then yours, along with what its views will show.
     */
    sideNav?: boolean;
    /**
     * Show the navigation panel's **Connections** entries — "How to connect"
     * (the storage list and the per-protocol guides: WebDAV · SFTP · FTPS · S3 ·
     * NFS · `filex mount`) and **API keys** (mint and revoke the tokens three of
     * those protocols sign in with).
     *
     * Default: on, EXCEPT under `uiProfile: 'simple'`, where it is off. Those two
     * defaults answer two different people: #14's reporter called mount
     * instructions power-user noise in front of users who are not in IT, and an
     * embedder's own tenant may still legitimately need an S3 key. Whichever one
     * you are, say so explicitly and the default stops mattering.
     *
     * ⚠ Not gated on role, ever. The backend decides what a caller may see —
     * ConnectionsPanel renders what the API returns, and `/api/tokens` caps every
     * scope against the caller's own role and grants. A UI-side role check here
     * would only hide the surface from the accounts that need it most; that is
     * the bug this became: for a year the sole place to mint the token the FTPS
     * guide told you to use was the admin panel.
     *
     * ⚠ Role is not the same question as `callerKind`. "API keys" IS hidden for
     * an app token — not because of what that caller may do, but because there is
     * no single person behind it whose keys they would be. See `callerKind`.
     *
     * ⚠ The entries live in the panel, so `sideNav: false` takes them with it.
     * Hosts that want the surface without the panel mount `<filex-connections>`
     * (or `ConnectionsPanel`) on a page of their own.
     */
    connections?: boolean;
    /**
     * Who is behind this explorer — a person, or an integration?
     *
     * `'user'` (a signed-in human, or their own API token) draws everything.
     * `'app'` suppresses the surfaces that only mean something for ONE person:
     * **API keys**, **Recent**, **Starred** and **Shared with me**. Upload, the
     * storage list, Trash and "How to connect" stay — an embed's users still
     * upload files and still need mount instructions.
     *
     * Why it exists: a filex API token authenticates AS its owner, and the embeds
     * we run authenticate every visitor with ONE shared token injected by the
     * host's proxy. v0.30.0 put "API keys" in the panel, so under that token an
     * embed visitor could list and revoke the credential the embed itself runs
     * on — and "your Recent" meant the token owner's history shown to a stranger.
     *
     * Default: read from `GET /api/files/capabilities` (`caller_kind`), which is
     * authoritative because only the server knows the token's kind (migration
     * 00030). Set this only to answer BEFORE that request lands — a host that
     * already knows it proxies with an app token spares its users the flash of a
     * Starred row that then disappears. A value here wins over the server's.
     */
    callerKind?: 'user' | 'app';
    /**
     * How a mouse opens an item.
     *
     *   'double' (default) — a single click SELECTS, a double click OPENS
     *                        (classic desktop file-manager). This is a
     *                        per-viewer preference the host may expose as a
     *                        setting.
     *   'single'           — a single click OPENS (the item is opened on the
     *                        first click; the checkbox is still the one click
     *                        that selects).
     *
     * ⚠ TOUCH is not governed by this: a finger tap always opens (the mobile
     * convention, and there is no hover-to-select on a touchscreen). The
     * checkbox always selects, on every device and in either mode. See
     * FilePane.onViewClick + composables/useRowTouch.
     */
    openTrigger?: 'single' | 'double';
    /**
     * Hand the OPEN of a file to the host instead of opening the in-page
     * preview/editor overlay. When true, opening a file emits `file-opened`
     * (path + basename) and the explorer does NOT mount its own PreviewModal —
     * the host decides what to do (the desktop app opens the file in its own
     * window per document). Directories still navigate inline, and Space
     * quick-look still peeks in-page. Default false (web/embeds preview inline).
     *
     * ⚠ Ignored inside an unlocked E2E-encrypted folder: the host window would
     * fetch raw server bytes (ciphertext), so those keep the in-page decrypted
     * preview.
     */
    openInHost?: boolean;
    /** Default view. */
    viewMode?: 'list' | 'grid';
    /**
     * Max upload size in MB.
     *
     * @deprecated IGNORED — declared, never read. There is no client-side size
     * check in the explorer at all (and the `/limits` fallback this comment used
     * to promise is not called either), so an embedder who set it watched
     * oversized uploads start anyway and fail at the server, which is the only
     * place the limit is enforced (FILEX_UPLOAD_* / the storage's own limits).
     * Left in place rather than removed so existing embeds keep compiling; do
     * not add a reader without also adding the pre-flight rejection the name
     * implies.
     */
    maxFileSizeMb?: number;
    /**
     * Accept patterns (MIME or extension).
     *
     * @deprecated IGNORED — declared, never read. No `accept` attribute is
     * rendered on any file input in the package and nothing filters a drop, so
     * setting it restricts nothing. Same note as `maxFileSizeMb`.
     */
    acceptTypes?: string[];
    /** Storage adapter to default to (avoids the initial flash). */
    defaultAdapter?: string;
    /**
     * Where to persist the current path so reload lands the user back
     * in the same folder.
     *   'hash'              — URL hash. Default — works on plain web pages.
     *   'localStorage'      — `brf-file-explorer:path` key. Best for SPAs that
     *                         already own the URL (Ionic / Vue Router / Next).
     *   'hash+localStorage' — both: the address bar always mirrors the
     *                         current folder (copy-paste deep links), and
     *                         localStorage remembers it for hash-less visits.
     *                         Read priority: hash → `initialPath` → localStorage.
     *   'none'              — don't persist. Embedder controls path externally.
     */
    pathPersist?: 'hash' | 'localStorage' | 'hash+localStorage' | 'none';
    /**
     * Multi-storage root mode. When true, the explorer's "/" virtual
     * folder lists every entry in `storages` as a clickable directory.
     * Clicking one drills into that storage's root; the breadcrumb
     * walks `/ › <storage> › <sub> › …`.
     *
     * When false (default) the SFC still works against a single
     * storage — `defaultAdapter` / `initialPath` decide which one.
     *
     * Pair with `storages` so the SFC has labels + driver hints to
     * render even before the first API call.
     */
    multiStorageRoot?: boolean;
    /**
     * Storage list for `multiStorageRoot` mode. Provide name + driver
     * + (optional) display label / read-only flag. The SFC mirrors
     * each entry as a virtual `dir` row at "/".
     */
    /**
     * tablo:t1 — remember how each folder was last viewed (view mode + sort),
     * Windows Explorer style. Default ON.
     *
     * ⚠ The opt-out exists for embeds. A product mounting filex in a two-inch
     * panel has one shape it wants and no room to argue with a gallery view
     * arriving from the person's main window; setting this false makes every
     * folder open in the host's chosen default and writes nothing. The columns
     * are NOT covered by this flag — their widths are a global preference about
     * the reader's screen, and a panel that narrow sheds them for want of room
     * before any preference is consulted.
     */
    rememberFolderView?: boolean;
    storages?: Array<{
        name: string;
        /**
         * tablo:t1 — the storage's immutable uid, when the host knows it.
         *
         * ⚠ A storage's NAME is editable — that is the point of a name — so it is
         * not a stable address, which is why every protocol also accepts the uid
         * as a path's first segment (`backend/internal/storageref`, filex issue
         * #21). Anything keyed on a storage for the long term should prefer this:
         * per-folder view memory does (`lib/viewPrefs.folderKey`), and folders
         * under a renamed storage keep their remembered view the moment a host
         * starts filling it in. Absent = the name is used and a rename loses the
         * memory, which is a mild, self-healing loss.
         */
        uid?: string;
        label?: string;
        driver?: string;
        readOnly?: boolean;
        /**
         * gorunum:v3-shell — bytes this storage holds, when the host knows. Drawn
         * as the caption on the Home view's storage card; absent means the card
         * names the kind of thing instead.
         *
         * ⚠ It must be the SAME quantity for every caller who gets it (in our own
         * app: `/api/admin/storages` for an operator, the RBAC-filtered
         * `/api/files/quota/storages` for everybody else). The per-USER quota is a
         * sum across every storage, so passing that here would print a number
         * about the person under a label about the drive.
         */
        usedBytes?: number;
    }>;
    /**
     * Desktop-shell hook — dragging rows OUT of the window onto the OS.
     *
     * Present only in the filex desktop app. A web page cannot hand the OS a
     * list of files: Chromium carries one `DownloadURL` per drag, so the browser
     * gets a single-file drag-out for free (the explorer sets it itself) and
     * folders/multi-selections need real local paths — which is what the shell
     * provides here.
     *
     * The bytes have to exist BEFORE the drag starts — the OS copies from a path
     * at drop time — and the shell has two ways to satisfy that, which is why
     * this is more than one call:
     *
     *   `prepare` — fetch local copies up front. The explorer calls it for small
     *     selections as soon as they are selected, so the common drag hands over
     *     real, complete files (correct even when the drop target is an
     *     application that reads the file immediately).
     *   `start` — begin the OS drag, whatever the size. The shell may hand the
     *     OS empty placeholders and download into wherever they land afterwards,
     *     so this is never gated on `prepare` having finished.
     *   `cancel` — the drag ended INSIDE the explorer (an internal move). The
     *     shell stops waiting for a drop it will never see.
     *
     * `onProgress` drives the explorer's toast; `error: 'drop_not_found'` means
     * the drop went somewhere the shell cannot write to (an application rather
     * than a folder) and nothing was transferred.
     */
    dragOut?: {
        prepare: (items: Array<{
            path: string;
            basename: string;
            type: 'file' | 'dir';
        }>) => Promise<{
            ready: boolean;
            error?: string;
        }>;
        start: (items: Array<{
            path: string;
            basename: string;
            type: 'file' | 'dir';
        }>) => void | Promise<void>;
        cancel?: () => void | Promise<void>;
        onProgress?: (cb: (p: {
            done: number;
            total: number;
            name?: string;
            dropped?: string;
            finished?: boolean;
            error?: string;
        }) => void) => void;
    };
    /**
     * Desktop-shell hook — selective sync ("keep on this computer").
     *
     * Present only when the explorer runs inside the filex desktop app; the
     * shell passes functions that talk to its sync engine, and the explorer
     * grows "Keep on this computer" / "Online only" entries on folder menus.
     * Absent (web admin, embeds): nothing about it renders.
     *
     * Folders only, by design: the sync engine pairs directories, and a file
     * rides along with the folder that holds it.
     */
    desktopSync?: {
        /** Kept folders for the mounted account, adapter-qualified remotes. */
        kept: () => Promise<Array<{
            remote: string;
            local: string;
        }>>;
        /** Start keeping a folder — or, with kind 'file', a single file.
         *  Resolves once the pair is registered (or the user cancelled the
         *  shell's root-folder prompt — re-read `kept`). */
        keep: (remote: string, kind: 'dir' | 'file') => Promise<void>;
        /** Stop keeping. The SHELL owns the "what happens to the local copy"
         *  question — it asks natively and may cancel; re-read `kept` after. */
        unkeep: (remote: string) => Promise<void>;
        /** Open the folder's local mirror in the OS file manager. */
        reveal: (remote: string) => Promise<void>;
        /** Live engine state, for the row badges and the bottom progress strip.
         *  `active` is the folder being worked on right now — the engine walks
         *  its pairs one at a time — or null between runs. */
        status?: () => Promise<{
            running: boolean;
            lastError?: string | null;
            active: {
                remote: string;
                phase: 'inventory' | 'plan' | 'transfer' | 'settling';
                done: number;
                total: number;
            } | null;
        }>;
        /** Subscribe to "something about sync changed" pokes from the shell —
         *  the explorer re-reads `kept` and `status` when poked. The shell keeps
         *  ONE subscriber (the mounted explorer) and overwrites it on remount. */
        onChange?: (cb: () => void) => void;
    };
}

/** Component emits — the parent listens for these events. */
export declare interface ExplorerEmits {
    'share-created': (payload: {
        path: string;
        url: string;
        pin: string | null;
    }) => void;
    'file-opened': (file: {
        path: string;
        basename: string;
    }) => void;
    error: (err: {
        message: string;
        context?: unknown;
    }) => void;
    'upload-progress': (p: {
        uploadId: string;
        percent: number;
        done: boolean;
    }) => void;
    'selection-change': (items: Array<{
        path: string;
        basename: string;
        type: 'file' | 'dir';
    }>) => void;
}

export declare type ExternalServiceState = 'ok' | 'error' | 'disabled' | 'unknown';

export declare interface ExternalServiceStatus {
    enabled: boolean;
    state: ExternalServiceState;
    url?: string;
    last_check?: string;
    detail?: string;
}

export declare type FileApi = ReturnType<typeof useFileApi>;

export declare const FileExplorer: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

/**
 * FileNode — node shape returned by the manager endpoint.
 *
 * Backend `?q=index` (or `GET /api/files/manager?action=index`) returns:
 *   { adapter, storages, dirname, files: FileNode[] }
 */
export declare interface FileNode {
    /** DB node ID — needed by the per-user meta routes (starred, tags,
     *  recently-opened). Backend's projectFileNodes() emits it for every
     *  row; only client-synthesized rows (e.g. multi-storage virtual
     *  folders) lack one. */
    id?: number;
    /** Full adapter-qualified path: `local://receipts/2024/invoice.pdf` */
    path: string;
    /** Relative basename: `invoice.pdf` */
    basename: string;
    /** Adapter-stripped relative path: `receipts/2024/invoice.pdf` */
    relativePath?: string;
    /** `file` or `dir` */
    type: 'file' | 'dir';
    /** Extension (lowercased, no dot). Empty string = no extension. */
    extension?: string;
    /** Bytes. 0 = directory. */
    size?: number;
    /** Unix ms (backend "last_modified"). */
    last_modified?: number;
    /** MIME. */
    mime_type?: string;
    /** Optional thumbnail URL (backend may inline). */
    thumb_url?: string | null;
    /** Visibility: private | public. */
    visibility?: 'private' | 'public';
    /** File count for directories. */
    count?: number;
    /** Client-side tag (localStorage or backend). */
    starred?: boolean;
    /** Hex color tag. */
    color?: string | null;
    /** Server-side trash marker. */
    trashed?: boolean;
    /** RBAC effective level for the current user on this entry (backend
     *  projectFileNodes emits it when a storage has RBAC on). '' / undefined =
     *  ACL not enforced. Used to gate edit/manage affordances client-side. */
    perm?: 'none' | 'viewer' | 'editor' | 'owner';
    /** The row sits on a read-only storage. Carried by the rows that come from
     *  OUTSIDE a folder listing — Recent, Starred, a tag view, the Home cards,
     *  the Recently-opened tray (`handlers/meta.go`) — because there the
     *  listing-level `read_only` has no folder to describe. A folder listing's
     *  rows leave it unset; `dirReadOnly` answers for the whole folder. Folded
     *  into the write gate with `perm`, so the context menu is the same in
     *  every view. */
    read_only?: boolean;
    e2e?: boolean;
    /** Generic — any additional fields the backend wants to inline. */
    [k: string]: unknown;
}

export declare const FilePane: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

/**
 * Does `combo` already trigger another action? Checks both effective
 * combos and the reserved fixed combos (Backspace, Esc). Returns null
 * when free.
 */
export declare function findShortcutConflict(combo: string, excludeId: string): ShortcutConflict | null;

/**
 * HOW MANY FOLDERS WE REMEMBER, and how the number was chosen.
 *
 * ⚠⚠ Without a cap this is one entry per folder ever visited, forever — and
 * now that the document lives in a database row rather than in a browser, it is
 * a row that grows without bound for the life of the account, replicated into
 * every backup. The endpoint refuses a document over 128 KB, so left uncapped
 * the failure would eventually be that saving stops working, silently, for the
 * people who use the product most.
 *
 * 300 is derived, not picked: an entry serialises to ~110 bytes (a qualified
 * folder path plus four short fields), so 300 of them is ~33 KB — comfortably
 * inside that limit with room for longer paths than the estimate assumed. And
 * it is far more folders than a person deliberately configures: the map only
 * gains an entry when someone CHANGES a view (see `touchFolder` — merely
 * walking through a folder writes nothing), so in real use the cap is never
 * reached and nothing is ever evicted. It is a ceiling on the pathological
 * case, not a working limit.
 */
export declare const FOLDER_CAP = 300;

/** True when this folder has a memory the PERSON made (not a seed) — what the
 *  "Reset this folder" affordance is gated on. */
export declare function folderIsRemembered(key: string): boolean;

/**
 * THE KEY a folder is remembered under.
 *
 * ⚠⚠ Read filex issue #21 before changing this. A storage's NAME is editable —
 * that is the point of a name — so it is not a stable address; every protocol
 * accepts a storage's immutable `uid` as the first path segment for exactly
 * that reason (`backend/internal/storageref`). This function therefore takes
 * the storage REF the host gave us and does not care which of the two it is:
 * the moment `config.storages[].uid` is populated, keys built here become
 * rename-proof with no change to this file.
 *
 * ⚠ Until then the key carries a storage NAME, and the consequences are worth
 * stating rather than hiding:
 *   · renaming a storage loses its folders' memory (they fall back to the
 *     global default — a mild, self-healing loss, and the LRU ages the orphans
 *     out);
 *   · deleting a storage and creating a new one with the SAME name hands the
 *     new one the old one's remembered views. Rare, bounded to view mode and
 *     sort, and the fix is the one line of plumbing named above.
 * What it does NOT do is collide across storages that exist at the same time,
 * because two live storages cannot share a name.
 *
 * The relative path is normalised so `a/b`, `/a/b/` and `a//b` are one folder.
 */
export declare function folderKey(storageRef: string, relPath: string): string;

export declare function folderMemoryEnabled(): boolean;

/**
 * One folder's remembered setup. Short keys on purpose — this is a map with
 * one entry per folder the person has configured, and the whole map is
 * re-serialised on every write.
 */
export declare interface FolderPrefs {
    /** view mode */
    v?: ViewMode_2;
    /** sort key */
    k?: SortKey;
    /** sort direction */
    d?: SortDir;
    /** last used, epoch SECONDS — the LRU clock. */
    t: number;
}

/**
 * What this folder is remembered as, or the seed, or nothing.
 *
 * ⚠⚠ The SEED is answered even when the memory is switched off, and the
 * stored map only when it is on. They are two different things wearing one
 * shape: the seed is what Recent sorts by — a property of that view, which the
 * owner asked for directly and which must not hinge on an unrelated preference
 * — while the map is the per-folder memory the preference governs. Putting the
 * gate here rather than at the caller is what keeps every caller from having to
 * remember the distinction.
 */
export declare function folderPrefs(key: string): Omit<FolderPrefs, 't'> | null;

/**
 * THE ESCAPE HATCH — "Apply to all folders".
 *
 * Forgets every per-folder memory. The caller has already written the current
 * folder's setup to the global default (every change does), so the visible
 * effect is that every folder now opens the way this one does, which is what
 * the words promise.
 */
export declare function forgetAllFolders(): void;

/** Forget one folder: it goes back to following the global default. */
export declare function forgetFolder(key: string): void;

/**
 * A byte count as a string — the ONE implementation.
 *
 * There were four: this file (1024, i18n units), `web/src/lib/format`
 * (1000, English units), `SideNav` (1024, hardcoded English units, next to a
 * quota line that `HomeView` rendered through the shared one), and
 * `Trash.vue` (1024, in a file already importing the admin helpers). A quota
 * of 10 GB read "10 GB" in the admin panel, "9.3 GB" in the side nav and
 * "9.31 GB" on the home screen — three spellings of one number.
 *
 * ⚠⚠ THE BASE IS 1000, and that is a decision, not an accident:
 *
 *   - "KB" / "MB" / "GB" are SI prefixes and mean powers of 1000. Rendering
 *     1024-arithmetic under those letters is simply mislabelled; being right
 *     at 1024 would mean printing KiB/MiB/GiB everywhere instead.
 *   - Both places in this product that CONVERT between a unit and bytes are
 *     already decimal, and both say so in a comment: the per-user quota input
 *     (`web/src/views/UserEdit.vue`, `GB = 1_000_000_000`) and the usage/cost
 *     path (`backend/internal/usage/b2.go`: "B2 bills in decimal GB, not GiB
 *     — using 1024³ here would quietly overstate every upload by 7%").
 *   - So decimal is the only base under which a quota typed as "10 GB" reads
 *     back as "10 GB" and a stored volume matches the invoice beside it.
 *
 * `base: 1024` exists for exactly one reason: mirroring a number some other
 * program already printed. Today that is the share message, which has to read
 * like `humanSize()` in backend/internal/api/handlers/mail_templates.go.
 * That is an argument to this function, not a fifth copy of it.
 */
export declare function formatByteSize(bytes: number | null | undefined, opts?: ByteSizeOptions): string;

/**
 * Render an instant for a human: the viewer's language AND the viewer's
 * chosen clock, together, in one call. Every date on every surface goes
 * through here — that is the whole point of it being here.
 */
export declare function formatInstant(d: Date, code: LocaleCode | string | undefined, opts: Intl.DateTimeFormatOptions, 
/** The explorer whose clock applies (EXPLORER_CLOCK); omitted = page-wide. */
owner?: symbol): string;

/**
 * Format 20 raw bytes as the string the user writes down:
 * `XXXX-XXXX-XXXX-XXXX-XXXX-XXXX-XXXX-XXXX` (160 bits, no padding waste).
 */
export declare function formatRecoveryKey(raw: Uint8Array): string;

/**
 * Freeze the widths currently ON SCREEN, for the columns that have none stored.
 *
 * ⚠⚠ Called by the view at the START of a resize gesture, and it has to write
 * EVERY drawn column, not the one being dragged. Writing only the dragged
 * column would leave Name auto — and auto Name takes the slack, so narrowing
 * Size would still widen Name, which is the exact behaviour the owner called
 * wrong. Freezing the whole row first turns the gesture into what it looks
 * like: one column changes, the others stay where they are.
 *
 * Existing entries are never overwritten: the widths handed in are what the
 * person is already looking at, and the stored ones are already that.
 */
export declare function freezeWidths(widths: Partial<Record<ColumnId, number>>): void;

/** What an FTP client needs to be told, computed on the server. */
declare interface FTPSFacts {
    enabled: boolean;
    host: string;
    port: number;
    /**
     * ⚠ The passive data-port range. A firewall that blocks it makes every
     * transfer HANG with no error on either side — the classic FTP failure, and
     * impossible to diagnose from the client end. It belongs in the guide.
     */
    pasv_min: number;
    pasv_max: number;
    /** True when no certificate was configured and the server generated one. */
    self_signed: boolean;
}

/** Mint a fresh user recovery key. Shown once, never stored by filex. */
export declare function generateRecoveryKey(): string;

/**
 * Generate a stylesheet that mirrors styles/variables.css' selector
 * cascade 1:1 (light base → explicit-dark selectors → prefers-dark media
 * block) with the theme's palette. Appended after the bundled CSS it
 * overrides every surface — teleported context menus, modal backdrops —
 * in whichever mode they resolve to, without JS having to track them.
 */
export declare function generateThemeCss(theme: ThemeDef): string;

export declare function getHighlight(): unknown | null;

/** Synchronous cached lookup — null if Monaco not yet ready or absent. */
export declare function getMonaco(): unknown | null;

declare function getPath(): string;

/**
 * One hit from the dedicated files-search endpoint. The backend returns raw
 * node rows (`{results: [...]}`), so `path` is the IN-STORAGE relative path
 * (no `adapter://` prefix) and the storage comes back as a numeric
 * `storage_id`. `snippet`/`matched` are the v0.2 "Bul" contract additions —
 * older backends simply omit them, so every consumer must stay
 * undefined-safe.
 */
export declare interface GlobalSearchHit {
    id?: number;
    storage_id?: number;
    name?: string;
    path?: string;
    /** `file` | `dir` (backend NodeType). */
    type?: string;
    size?: number;
    mime?: string;
    /** Plain-text content snippet; matches wrapped in «» (never HTML). */
    snippet?: string;
    /** Where the hit matched: name | content | both. */
    matched?: 'name' | 'content' | 'both';
    [k: string]: unknown;
}

export declare type GlobalSearchScope = 'name' | 'content' | 'all';

declare function goUp(): void;

/** A single ACL grant row (RBAC permissions panel). */
declare interface Grant {
    id: number;
    storage_id: number;
    path_prefix: string;
    user_id: number;
    level: 'viewer' | 'editor' | 'owner';
    user_email?: string;
    user_display_name?: string;
    inherited?: boolean;
}

export declare function groupByDate<T>(items: readonly T[], opts: DateGroupOptions<T>): DateGrouping<T>;

/**
 * Is a date heading honest over THIS listing?
 *
 * Both halves are required and neither is cosmetic:
 *   - the key has to be `modified`, because that is the only order in which
 *     consecutive rows share a day;
 *   - the listing must not be the server's RANKED answer, where the key is
 *     still `modified` (nothing cleared it) and the rows simply are not
 *     obeying it.
 *
 * Sorting by name with date headings on would be exactly the lie above, so
 * every other key draws no headings at all — in all three views.
 */
export declare function groupingActive(key: SortKey, order: ListingOrder | undefined): boolean;

/**
 * Protocol id → builder.
 *
 * S3 and SFTP land here as one entry each once their servers exist; the
 * panel, the copy buttons, the client tabs and the i18n plumbing are
 * already written for them. That is the whole point of the shape.
 */
export declare const GUIDE_BUILDERS: Record<string, GuideBuilder>;

export declare interface GuideBlock {
    kind: GuideBlockKind;
    /** Prose for `text` / `note` / `warn`. */
    text?: string;
    /** Ordered instructions for `steps`. */
    steps?: string[];
    /** Copyable payload for `code`. */
    code?: string;
    /** Syntax hint / file name shown above a code block. */
    caption?: string;
}

export declare type GuideBlockKind = 'text' | 'steps' | 'code' | 'note' | 'warn';

export declare type GuideBuilder = (ctx: GuideContext, t: Translate) => ProtocolGuide;

export declare interface GuideClient {
    id: string;
    /** Product name — never translated ("Cyberduck" is Cyberduck). */
    name: string;
    platform: 'windows' | 'macos' | 'linux' | 'any';
    blocks: GuideBlock[];
}

/** Everything a guide is allowed to know about the deployment. */
export declare interface GuideContext {
    /** Absolute origin of the server, e.g. `https://fm.example.com`. */
    origin: string;
    /** The caller's own account e-mail — the username on every protocol. */
    user: string;
    /** Storage names the caller may see. */
    storages: string[];
    /** The storage the page is currently focused on, when any. */
    storage?: string;
    /**
     * The S3 endpoint, as the server computes it.
     *
     * ⚠ NOT derived from `origin` here. With a dedicated host the endpoint is
     * that host's root; without one it lives under `/s3`, and a client pointed
     * at the application root reaches the web app — rclone reported
     * "XML syntax error on line 10" against an HTML redirect page. The server
     * returns this with every key, and the guide repeats it verbatim.
     */
    s3Endpoint?: string;
    /** True when clients must be told to force path-style addressing. */
    s3PathStyle?: boolean;
    /** The access key id to write into the examples, when the caller has one. */
    s3AccessKeyID?: string;
    /** The freshly minted secret, shown only while the user is looking at it. */
    s3Secret?: string;
    /** The SFTP endpoint, as the server reports it. */
    sftpHost?: string;
    sftpPort?: number;
    /** False when the operator has the endpoint switched off. */
    sftpEnabled?: boolean;
    /** The login name a client must use — the username when there is one. */
    sftpLogin?: string;
    /** True when the account has at least one usable key registered. */
    sftpHasKey?: boolean;
    /** The FTPS endpoint, as the server reports it. */
    ftpsHost?: string;
    ftpsPort?: number;
    ftpsEnabled?: boolean;
    /** The passive data-port range, which the client's firewall must allow. */
    ftpsPasvMin?: number;
    ftpsPasvMax?: number;
    /** True when the server is using a self-signed certificate. */
    ftpsSelfSigned?: boolean;
    /** The NFS endpoint, as the server reports it. */
    nfsHost?: string;
    nfsPort?: number;
    nfsEnabled?: boolean;
    /** The freshly minted export path — the credential, shown once. */
    nfsPath?: string;
    /** True when the active export refuses writes. */
    nfsReadOnly?: boolean;
}

/** One connection fact, rendered as a copyable row. */
export declare interface GuideFact {
    label: string;
    value: string;
    hint?: string;
    /** Rendered as a hint rather than a value — filex never has the
     *  plaintext of your password and must not pretend otherwise. */
    placeholderOnly?: boolean;
}

/** Protocol ids that have a guide, in display order. */
export declare function guideProtocols(): string[];

/** True when the buffer starts with the 'filexe2e' magic. */
export declare function hasMagic(data: ArrayBuffer | Uint8Array): boolean;

/** `https://fm.example.com` → `fm.example.com`; anything unparseable comes back whole. */
export declare function hostOf(origin: string): string;

/** Import the escrow private key the admin pastes in (base64 PKCS#8, PEM tolerated). */
export declare function importEscrowPrivateKey(pkcs8B64: string): Promise<CryptoKey>;

/** Import the installation escrow public key (base64 SPKI, as the server serves it). */
export declare function importEscrowPublicKey(spkiB64: string): Promise<CryptoKey>;

/**
 * Where the picker should open.
 *
 * The current folder, because that is where the person is standing and most
 * destinations are near it. Falls back to the drives list when there is more
 * than one storage and no current folder, and to the single storage's root
 * when there is only one.
 */
export declare function initialLocation(current: string | undefined, storages: string[] | undefined): string;

declare interface InviteResponse {
    mode: 'granted' | 'user_created' | 'shared';
    user_id?: number;
    url?: string;
    temp_password?: string;
    emailed: boolean;
}

/** Is `child` the same as, or inside, `ancestor`? Both are wire paths. */
export declare function isAtOrInside(child: string, ancestor: string): boolean;

/** Single source of truth for "is the IdP/editor/diagram service ready?".
 *  A capability is usable only when both flags say so — `enabled=true` but
 *  `state='error'` means an operator turned it on but a probe just failed,
 *  and we'd rather hide the entry than offer a button that 500s on click.
 */
export declare function isExternalUsable(s: ExternalServiceStatus | undefined): boolean;

/**
 * Is this a Mac-style keyboard? Only affects how a combo is PRINTED —
 * the canonical form folds Meta into Ctrl, so one saved combo works on
 * every platform and only the label differs.
 */
export declare function isMacLike(): boolean;

/** True when the deployment is not on TLS — several clients refuse that,
 *  and Windows refuses it silently, which is worse. */
export declare function isPlainHttp(origin: string): boolean;

/** Does the browser eat this combo before the page can see it? */
export declare function isReservedCombo(combo: string): boolean;

/** True when the staged protocol is simply not there. */
export declare function isStagedUnsupported(err: unknown): boolean;

/**
 * True when the engine accepts `tz` as an IANA zone.
 *
 * ⚠ The check is a real formatter construction, not a lookup in the list
 * below: `supportedValuesOf` is the engine's *canonical* set and does not
 * contain the aliases it nonetheless accepts (`Asia/Istanbul`,
 * `US/Pacific`, …). The value may have come from another device, another
 * browser, a host page or a hand-edited account row.
 */
export declare function isValidTimeZone(tz: string): boolean;

/** Rebuild `adapter://rel`. An empty rel is the storage root. */
export declare function joinWire(adapter: string, rel: string): string;

/** The last segment of a wire path — what a breadcrumb or a row shows. */
export declare function labelOfWire(p: string, drivesLabel: string): string;

/**
 * WHERE A LISTING'S ORDER CAME FROM — the third state the old `key: null`
 * used to express, back as a mode rather than as a fourth key.
 *
 *   `sort`      — a folder's contents. The key and the direction below decide
 *                 the order, which is what every control in the UI drives.
 *   `relevance` — a RANKED answer. The server decided the order and it is the
 *                 whole value of the reply; re-applying a key here buries the
 *                 row the person came for.
 *
 * ⚠⚠ Why a mode and not a key. A key is a preference: it is persisted, it is
 * named by a button, and the user picks it. "Relevance" is none of those — it
 * is a FACT about the rows in hand, it must not outlive them, and there is no
 * meaningful "relevance descending". Making it a fifth member of `SortKey`
 * would have persisted it into the next folder (where nothing is ranked) and
 * put a word in the Sort-by menu that does nothing in nine listings out of
 * ten.
 *
 * ⚠⚠ …and why it is an ARGUMENT and not a field on the store. The store is a
 * pane's preference; this is a property of the ROWS a pane happens to be
 * holding, and one pane can be showing a search while the other shows a
 * folder. Same pane, two navigations, two answers — the caller holding the
 * rows is the only one that knows which it has.
 *
 * Measured, 2026-09-13 (qldemo, query `s`, Name ↑): the server ranked
 * `Documents/server.ts` first and the list drew it fifteenth of seventeen,
 * behind every alphabetically earlier row. The owner's ruling that day:
 * ordinary search and ⌘K stay in relevance order.
 */
declare type ListingOrder = 'sort' | 'relevance';

/** Every unfinished upload this browser knows about, newest first. Surfaces
 *  use it to say "you have an unfinished upload" instead of forgetting. */
export declare function listResume(store: ResumeStorage | null, now?: number): ResumeRecord[];

/**
 * One folder, through the SAME `api.index` + `lib/listing` helpers the host's
 * own loader uses — so the two panes cannot end up listing different rows for
 * the same folder (the internal-entry filter and the virtual `.trash` row are
 * both shared functions, not copies).
 */
declare function loadFolder(target?: string): Promise<void>;

/** The record for this exact (destination, file), or null. */
export declare function loadResume(store: ResumeStorage | null, key: string, now?: number): ResumeRecord | null;

export declare type LocaleCode = 'tr' | 'en';

/** The BCP-47 tag a catalogue code means. ONE mapping, for every surface. */
export declare function localeTag(code: LocaleCode | string | undefined): string;

/**
 * Why the caller cannot manage storages, when they cannot.
 *
 * `none` is the honest answer for a signed-in non-admin: the surface then
 * shows the connection guides (which every user needs) and a plain "ask
 * your administrator" line instead of a form that would 403 on submit.
 */
export declare type ManageDenial = 'none' | 'anonymous' | 'unreachable';

export declare interface ManagerResponse {
    adapter: string;
    storages: string[];
    dirname: string;
    read_only: boolean;
    /** RBAC effective level for the current user on this directory ('' when ACL
     *  is not enforced on the storage). Gates the folder-level write actions. */
    perm?: 'none' | 'viewer' | 'editor' | 'owner';
    e2e?: boolean;
    e2e_root?: string;
    files: FileNode[];
}

/** True when the folder has an operator escrow slot. */
export declare function markerHasEscrow(m: E2eMarker | null): boolean;

/** True when the folder has a user recovery key slot. */
export declare function markerHasRecovery(m: E2eMarker | null): boolean;

/** True when the hit matched (at least partly) inside file CONTENT. */
export declare function matchedInContent(matched: unknown): boolean;

/**
 * Menu action key → registry action id.
 *
 * The right-click menu, the toolbar and the keyboard all name the same verbs,
 * but the menu's `key` and the registry's `id` are separate vocabularies and
 * two of them genuinely differ (`access` is the share dialog, `details` is the
 * inspector). One map, in one place: a second copy is a second chance to
 * forget, and the symptom would be a menu row that silently stops naming its
 * key while every other row keeps working.
 */
export declare const MENU_ACTION_SHORTCUTS: Record<string, string>;

/**
 * What a menu row or a toolbar button should print beside its label: the
 * current combo for the verb it triggers, or '' when it has none (unbound, or
 * not a registry action at all — `keep-local`, the E2E entries and so on).
 */
export declare function menuShortcutHint(menuKey: string): string;

export declare const messages: Record<LocaleCode, Record<string, string>>;

declare type ModifiedFilter = 'any' | 'today' | '7d' | '30d' | 'year' | 'around';

/** Put `id` at `index` in the order. Everything else closes up behind it. */
export declare function moveColumn(id: ColumnId, index: number): void;

/** One step left or right — what the header menu offers, so the whole gesture
 *  is reachable without a pointer. */
export declare function moveColumnBy(id: ColumnId, delta: -1 | 1): void;

/**
 * What Name opens at when nobody has ever dragged anything.
 *
 * 220px holds roughly 26 characters at 13px/500 — enough for
 * `Quarterly Report Q2.pdf` to read whole, which is the length of a real
 * document name rather than a demo fixture's. The auto pass never goes below
 * it: on a phone it would rather let the table run off the side (it is going
 * to anyway, with six columns on a 390px screen) than open showing eleven
 * characters of every filename.
 */
export declare const NAME_AUTO = 220;

/**
 * THE NAME COLUMN'S HARD FLOOR — how narrow a person may drag it.
 *
 * 120px, which at the list's 13px/500 is the 24px type tile, its 8px gap and
 * about eleven characters. Short, and deliberately so: the owner asked to be
 * able to shrink Name ("istersem name'i de kısabilir olmalıyım"), and a floor
 * that refuses at 220 would be the old behaviour wearing a smaller number.
 * Below 120 the cell is the tile and an ellipsis — a column that has stopped
 * being a name column at all — so that is where it stops.
 *
 * ⚠ Not to be confused with `NAME_AUTO`: this is what a DRAG may reach, that
 * is what an untouched table opens at.
 */
export declare const NAME_MIN = 120;

/**
 * One document type the SERVER can create, from `capabilities.newdoc_types`.
 *
 * ⚠ `requires` is the whole point of shipping this list instead of hardcoding
 * one in the client. The server knows it holds template bytes for `.docx`; it
 * does NOT know whether this deployment has a document server that can open
 * one. So it names the dependency and the client — which already resolves
 * OnlyOffice/drawio, config override included — answers it. A client that
 * re-derived "docx needs OnlyOffice" from a list of its own would be a second
 * source of truth, and the one that rots first.
 */
export declare interface NewDocType {
    /** Extension without the dot, lowercase. Also the key the create call sends. */
    ext: string;
    /** Coarse family, used for the picker's section headings. */
    group: 'document' | 'text' | 'diagram';
    mime: string;
    /** External service the editor for this type needs; absent = built-in. */
    requires?: 'onlyoffice' | 'drawio';
}

export declare const NewDocumentModal: DefineComponent<__VLS_Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (payload: {
message: string;
}) => any;
close: () => any;
created: (file: NewFileResponse) => any;
}, string, PublicProps, Readonly<__VLS_Props_6> & Readonly<{
onError?: ((payload: {
message: string;
}) => any) | undefined;
onClose?: (() => any) | undefined;
onCreated?: ((file: NewFileResponse) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** Answer to `?action=newfile` — where the new document actually landed. */
declare interface NewFileResponse {
    /** Adapter-qualified path, ready to hand to the viewer. */
    path: string;
    /** Final basename, which may have gained the extension server-side. */
    name: string;
    ext: string;
    size: number;
    mime: string;
}

/** Where an NFS client should point, reported by the server. */
export declare interface NFSConnection {
    /** The FILEX_NFS kill switch. */
    enabled: boolean;
    host: string;
    /**
     * ⚠ 2049 by convention, but filex serves mount AND nfs on this one port and
     * runs no portmapper — so a client needs `port=` and `mountport=` both set to
     * it. A guide that omitted either produces a mount that hangs.
     */
    port: number;
}

/**
 * NFS exports, as the frontend sees them.
 *
 * ⚠⚠ The `path` a freshly minted export returns IS the credential. NFSv3 cannot
 * authenticate a request without Kerberos, so filex binds the identity to the
 * export path instead: 32 bytes of entropy, shown once, stored hashed. Whoever
 * knows it can mount as that account — which is why it belongs in a config file
 * treated like a password, and why the UI has to say so rather than letting
 * somebody discover it from a mount table.
 */
export declare interface NFSExport {
    id: number;
    user_id: number;
    api_token_id?: number | null;
    label: string;
    /** Confinement, in the same shape the S3 keys use. */
    storage_name?: string;
    prefix?: string;
    /** Refuses every write through this mount, whatever the account may do. */
    read_only: boolean;
    /** Comma-separated CIDR allow-list. Empty = any address the listener takes. */
    allow_cidrs?: string;
    created_at: string;
    last_used_at?: string | null;
    expires_at?: string | null;
    disabled_at?: string | null;
}

/** What minting returns. The path appears exactly once. */
export declare interface NFSExportCreated extends NFSConnection {
    export: NFSExport;
    path: string;
}

export declare const NFSExportsPanel: DefineComponent<__VLS_Props_24, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
host: string;
port: number;
enabled: boolean;
path?: string;
readOnly: boolean;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_24> & Readonly<{
onActive?: ((v: {
host: string;
port: number;
enabled: boolean;
path?: string;
readOnly: boolean;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

/** Mirrors backend `model.NodeComment` (GET /api/files/comments?node_id=…). */
declare interface NodeComment {
    id: number;
    node_id: number;
    user_id: number;
    body: string;
    created_at: string;
    updated_at?: string;
    /** Joined author display name (email fallback), filled by the backend. */
    author_name?: string;
    /** Whether the CURRENT caller may delete this row (author or admin). */
    can_delete?: boolean;
}

/** Mirrors backend `model.NodeVersion` (GET /api/files/versions?node_id=…). */
declare interface NodeVersion {
    id: number;
    node_id: number;
    version_n: number;
    storage_key?: string;
    size: number;
    etag?: string;
    created_at: string;
}

export declare interface Operation {
    /** `${group}:${id}` — unique across publishers. */
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    queued: boolean;
    doneCount: number | null;
    totalCount: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    startedAt: number;
    settledAt: number | null;
}

export declare interface OperationActions {
    cancel?: () => void;
    /** Clean the row out of the OWNING source list (called on retire/dismiss). */
    dismiss?: () => void;
    retry?: () => void;
}

/** What a publisher hands to `sync()` for one row. */
export declare interface OperationInput {
    /** Stable id within the group (upload uuid / ops row id). */
    id: string | number;
    kind: OperationKind;
    /** Primary label — file name or target path. '' → renderer falls back to the kind verb. */
    name: string;
    /** 0..100, or null for indeterminate (renderer shows a spinner). */
    percent: number | null;
    status: OperationStatus;
    error?: string | null;
    /** Queue op accepted but not started yet ("Queued"). */
    queued?: boolean;
    /** Progress counters for queue ops (3/5 items). */
    doneCount?: number;
    totalCount?: number;
    /** Byte progress for uploads. */
    uploadedBytes?: number;
    totalBytes?: number;
    cancellable?: boolean;
    retryable?: boolean;
}

/**
 * useOperations — unified long-running-operation store (wiring:c3).
 *
 * One presentation-level aggregation point for everything that used to be
 * scattered across corner UIs:
 *   - uploads        (useUploadChunked jobs / legacy multipart rows)
 *   - ops-queue jobs (usePendingOps copy/move/delete worker ops)
 *   - future kinds   (convert / archive — same `sync()` contract, own group)
 *
 * The store does NOT talk to the network. Publishers (renderless
 * UploadProgress / PendingOpsTray adapters) reconcile their reactive source
 * lists into the store via `sync(group, items)`; OperationsCenter renders the
 * merged picture (badge + panel). Action callbacks (cancel/retry/dismiss)
 * are registered per row so the panel can route user intent back to the
 * owning surface without the store knowing any transport details.
 *
 * Lifecycle rules (per the Operations Center contract):
 *   - running rows live in `active`;
 *   - done/aborted rows linger in `active` for DONE_LINGER_MS ("done"
 *     flash) then move to `history` (session-only, capped);
 *   - error rows are STICKY: they stay in `active` until the user
 *     dismisses or retries them — even after the source list swept them
 *     (usePendingOps drops terminal ops after its RETAIN window).
 */
export declare type OperationKind = 'upload' | 'copy' | 'move' | 'delete' | 'convert' | 'archive';

export declare const OperationsCenter: DefineComponent<__VLS_Props_13, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_13> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
rootEl: HTMLDivElement;
}, any>;

export declare type OperationsStore = ReturnType<typeof useOperations>;

export declare type OperationStatus = 'running' | 'done' | 'error' | 'aborted';

/** 0–100, or `null` when there is no honest number to draw. */
export declare function opPercent(op: OpProgressLike): number | null;

/**
 * opProgress — the one rule for "how far along is this queued operation".
 *
 * Both progress surfaces read it: the explorer's operations center
 * (PendingOpsTray → OperationsCenter) and the admin app's bottom-right tray.
 * Two copies of this rule are how one tray starts saying something the other
 * does not (filex lesson #119).
 *
 * Issue #27: a queued op counts SOURCES, so moving one large file — or one
 * folder of a thousand files — is "0 of 1" until the very end. Drawn as a
 * percentage that is a bar frozen at 0% that then vanishes, which the reporter
 * read as stuck. So:
 *
 *   - a running cross-storage transfer reports bytes (`bytes_done` /
 *     `bytes_total`); when the total is known that is the percentage;
 *   - bytes moving with no total yet, or a single source with nothing but a
 *     source count, has NO honest percentage: `null`, and the surface shows
 *     an indeterminate indicator instead of a fake 0%;
 *   - several sources still report per source, as before.
 */
export declare interface OpProgressLike {
    status: string;
    progress_total: number;
    progress_done: number;
    bytes_total?: number;
    bytes_done?: number;
}

declare type PaneId = 'main' | 'split';

/**
 * The wire path one level up, or null when there is nowhere further up.
 *
 * `multiDrive` decides what sits above a storage root: with more than one
 * storage the answer is the list of drives, with exactly one there is nothing
 * above the root and the Up button must be disabled rather than land the user
 * on a one-row list of the drive they are already in.
 */
export declare function parentOfWire(p: string, multiDrive: boolean): string | null;

/** Parse marker JSON text; returns null when the shape is not a marker we read. */
export declare function parseMarker(text: string): E2eMarker | null;

/**
 * Parse a typed-in recovery key back to its 20 bytes, or null when it is not
 * one. Forgiving about how a human retypes it: case, dashes, spaces and the
 * Crockford look-alikes (O to 0, I/L to 1) are all normalised away.
 */
export declare function parseRecoveryKey(s: string): Uint8Array | null;

/** gorunum:v1-advsearch — what the path choice does to a row outside `pathBase`. */
declare type PathMode = 'any' | 'here' | 'skip';

export declare interface PendingOp {
    id: number;
    op_type: 'copy' | 'move' | 'delete';
    status: 'pending' | 'running' | 'done' | 'error';
    progress_total: number;
    progress_done: number;
    /** Running cross-storage transfer's bytes (issue #27); absent otherwise. */
    bytes_total?: number;
    bytes_done?: number;
    target_path: string | null;
    source_dir: string | null;
    source_count: number;
    error_message: string | null;
    started_at: string | null;
    finished_at: string | null;
    created_at: string | null;
}

/** Server-side PendingOp DTO (mirror of Modules\FishApp\Models\PendingOp::toApiArray). */
export declare interface PendingOpDto {
    id: number;
    op_type: 'copy' | 'move' | 'delete';
    status: 'pending' | 'running' | 'done' | 'error';
    progress_total: number;
    progress_done: number;
    target_path: string | null;
    source_dir: string | null;
    source_count: number;
    error_message: string | null;
    started_at: string | null;
    finished_at: string | null;
    created_at: string | null;
}

/**
 * Who a row belongs to. `any` is the neutral member every pill group needs;
 * `me` is the signed-in account, `system` is an ownerless row, and `u:<id>`
 * names one of the other accounts that actually appear in this listing.
 *
 * ⚠ The account members are NOT a fixed list. Offering every account on the
 * install would put names in the menu that cannot narrow anything here and
 * would leak the user directory into a folder view; `peopleOptions` derives
 * the choices from the rows in hand.
 */
declare type PeopleFilter = 'any' | 'me' | 'system' | `u:${number}`;

/**
 * May the caller write into a folder with this `perm`?
 *
 * ⚠ `undefined` AND `''` both mean "this storage does not enforce ACL", which
 * is the pre-RBAC default and full access. The declared type says one of four
 * levels, but the wire really does carry `''` for an unenforced storage, so
 * reading both as allowed is the truthful reading and not a convenience.
 *
 * This is deliberately the same predicate as `FileExplorer.permCanEdit` and
 * `NewDocumentModal.permAllowsWrite`. Two answers to "may I write here" is how
 * a dialog ends up offering a destination the toolbar hides.
 */
export declare function permAllowsWrite(perm: string | undefined | null): boolean;

declare interface PermissionsResponse {
    path: string;
    storage_rbac: boolean;
    direct: Grant[];
    inherited: Grant[];
    effective: string;
}

/**
 * useMonacoLoader — fire-and-forget Monaco preloader.
 *
 * The preview/edit flow wants Monaco when available (best-in-class
 * editor) and highlight.js for read-only syntax colour as a graceful
 * fallback. Monaco is heavy (~5 MB), so we kick off the dynamic import
 * at module-init time — by the time the user clicks "edit" on a code
 * file (typically several seconds in), the chunk is already cached.
 *
 *   - `monacoPromise`     resolves to the Monaco namespace, or `null`
 *                         if the package is not installed (peer
 *                         missing) / load fails.
 *   - `highlightPromise`  resolves to the highlight.js export, or
 *                         `null` similarly.
 *   - `getMonaco()`       returns the cached module synchronously
 *                         (after `await monacoPromise`) so a click
 *                         handler doesn't re-trigger the import.
 *
 * Both modules are externalized in the bundler config — the consumer
 * either declares them as direct deps (Monaco UX) or doesn't (the
 * highlight.js read-only path takes over). No build-time hard dep here.
 */
/**
 * Kick off the Monaco import the first time someone calls
 * `preloadEditor()` (typically the FileExplorer onMounted hook). Cheap
 * to call repeatedly — only the first call actually triggers the
 * dynamic import.
 */
export declare function preloadEditor(): void;

export declare const PreviewModal: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
starred: (value: boolean) => any;
close: () => any;
share: () => any;
nav: (delta: number) => any;
}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
onStarred?: ((value: boolean) => any) | undefined;
onClose?: (() => any) | undefined;
onShare?: (() => any) | undefined;
onNav?: ((delta: number) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
viewerEl: HTMLDivElement;
imgEl: HTMLImageElement;
markdownEl: HTMLDivElement;
monacoEl: HTMLDivElement;
officeEl: HTMLDivElement;
}, any>;

/**
 * Probe one external service from the browser running this page.
 *
 * Returns `skipped` — never a failure — for a service with no URL and for a
 * service filex does not load in the browser at all (the converter), because
 * reporting "unreachable" for something the browser never fetches would be a
 * new lie in place of the old one.
 */
export declare function probeExternalFromBrowser(service: string, base: string | null | undefined, opts?: {
    timeoutMs?: number;
    deps?: Partial<BrowserProbeDeps>;
}): Promise<BrowserProbeResult>;

export declare interface ProtocolGuide {
    id: string;
    /** Protocol name — a wire protocol is not translated either. */
    name: string;
    summary: string;
    /** Server + credential, filled in from this deployment. */
    facts: GuideFact[];
    clients: GuideClient[];
    notes: GuideBlock[];
}

/** Drop records older than RESUME_TTL_MS. Returns what survived. */
export declare function pruneResume(store: ResumeStorage | null, now?: number): Store;

export declare const QuickLook: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
starred: (value: boolean) => any;
close: () => any;
share: () => any;
nav: (delta: number) => any;
"open-full": () => any;
}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{
onStarred?: ((value: boolean) => any) | undefined;
onClose?: (() => any) | undefined;
onShare?: (() => any) | undefined;
onNav?: ((delta: number) => any) | undefined;
"onOpen-full"?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** surucu:d1 — `GET /api/files/quota/me` (quota.Snapshot). */
declare interface QuotaSnapshot {
    used_bytes: number;
    quota_bytes: number;
    percent_used: number;
    unlimited: boolean;
}

export declare const RecentlyOpened: DefineComponent<__VLS_Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (message: string) => any;
open: (node: RecentNode) => any;
context: (node: RecentNode, ev: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_5> & Readonly<{
onError?: ((message: string) => any) | undefined;
onOpen?: ((node: RecentNode) => any) | undefined;
onContext?: ((node: RecentNode, ev: MouseEvent) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare interface RecentNode {
    id: number;
    storage_id: number;
    path: string;
    name: string;
    mime?: string;
    last_opened?: string;
    /** The raw row carries more (`storage`, `perm`, `read_only`, `type`,
     *  the mtimes…) — the explorer turns it into a FileNode for the context
     *  menu with the same converter Recent / Starred / a tag view use. */
    [k: string]: unknown;
}

export declare const RecoveryKeyModal: DefineComponent<__VLS_Props_17, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
}, string, PublicProps, Readonly<__VLS_Props_17> & Readonly<{
onClose?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** Withdraw everything `owner` registered — call it on unmount. */
export declare function releaseTimeZoneOwner(owner: symbol): void;

declare function reload(): Promise<void>;

/** The account zone remembered in this browser by the last session. */
export declare function rememberedAccountTimeZone(): string;

/** How many folders are remembered — the "Apply to all folders" copy says so,
 *  because an escape hatch that does not say what it throws away is a trap. */
export declare function rememberedCount(): number;

/**
 * Remember a change against this folder.
 *
 * ⚠ The ONLY thing that creates an entry. Navigation does not (see
 * `touchFolder`), so the map stays the set of folders somebody deliberately
 * set up rather than a log of everywhere they have ever been — which is both
 * why the cap is never reached in practice and why "Apply to all folders" has
 * a small, comprehensible number to report.
 */
export declare function rememberFolder(key: string, patch: Omit<FolderPrefs, 't'>): void;

/**
 * Ask the server to prepare an archive of `paths` and return the ticket.
 *
 * Throws the same shaped error every other call in useFileApi throws — a
 * localized `message` plus `status`/`detail` — so a caller can toast
 * `err.message` and branch on `err.status` (409 = nothing readable in the
 * selection, 413 = too many files).
 */
export declare function requestArchive(api: Pick<FileApi, 'jsonFetch' | 'endpoints'>, paths: string[], name?: string): Promise<ArchiveTicket>;

export declare function resetAllShortcuts(): void;

/** Back to the shipped widths, order and visibility — one button for all
 *  three, because "reset the columns" is one thought. */
export declare function resetColumns(): void;

export declare function resetShortcut(id: string): void;

export declare interface ResolvedTimeZone {
    /** The zone to hand `Intl`; `undefined` = the device, resolved live. */
    zone: string | undefined;
    /** Which tier it came from. */
    tier: TimeZoneTier;
}

/** The resolved zone AND the tier it came from. Reactive. */
export declare function resolvedTimeZone(): ResolvedTimeZone;

declare interface ResolveEmailResponse {
    found: boolean;
    user?: {
        id: number;
        email: string;
        display_name: string;
        role: string;
    };
}

/**
 * Resolve a Vuefinder-compatible endpoint map from the user's config.
 * Either `apiBase` is set (auto-derive everything) or each route is
 * supplied explicitly (legacy). Mixed mode works too — explicit fields
 * trump the derived URL.
 */
export declare function resolveEndpoints(config: ExplorerConfig): EndpointMap;

/**
 * Resolve the locale to render in.
 *
 * Order, and the reasoning for it:
 *
 *   1. **What the host asked for.** An explicit `locale` always wins. A host
 *      that names a language has made a decision, and guessing over it would
 *      make the prop advisory.
 *   2. **What the browser asks for**, via `navigator.languages` /
 *      `navigator.language` — the same signal `Accept-Language` carries, and
 *      the reason a Turkish reader gets Turkish without the embedder doing
 *      anything.
 *   3. **`en`.**
 *
 * ⚠ Step 2 makes the same embed render differently for two people. That is
 * deliberate — it is what "follow the browser" means — but it also means a
 * screenshot, a test or a bug report about this component must state its
 * locale, because the component alone no longer determines it. Pass an
 * explicit `locale` anywhere the answer has to be stable.
 *
 * Matching is on the primary subtag, so `tr-TR` and `en-GB` resolve; anything
 * with no catalogue falls through rather than half-rendering.
 */
export declare function resolveLocale(explicit?: LocaleCode | '' | null): LocaleCode;

/**
 * Walk `TIME_ZONE_TIERS` and return the first tier with a usable zone.
 *
 * Pure — the reactive state below feeds it, and so can a test, or a surface
 * that needs to say what a default WOULD be (the embed's dialog asks it with
 * the viewer tier blanked, to label its "use the default" row).
 */
export declare function resolveTimeZone(sources: TimeZoneSources): ResolvedTimeZone;

/**
 * The profile to draw for whatever the host passed.
 *
 * `undefined` / `null` / `''` are "nothing was passed" and resolve to the
 * default in silence. Any OTHER unrecognised value is a mistake worth a line
 * in the console, because it means somebody asked for something by name and
 * got something else.
 */
export declare function resolveUiProfile(value: unknown): UiProfile;

/** How long an unfinished record is worth keeping. The server sweeps its own
 *  staging after FILEX_UPLOAD_STAGING_TTL (24 h by default); a note that
 *  outlives the bytes it describes only produces a confusing "resuming…" that
 *  immediately restarts. */
export declare const RESUME_TTL_MS: number;

export declare interface ResumeRecord {
    /** Server-side staged upload id. */
    uploadId: string;
    /** Destination directory, qualified (`adapter://sub/dir`). */
    path: string;
    name: string;
    size: number;
    /** File.lastModified — part of the identity, not metadata. */
    lastModified: number;
    chunkSize: number;
    /** Last offset the server acknowledged. Display + triage only. */
    offset: number;
    updatedAt: number;
}

/** A Storage-shaped thing. Injected so tests (and any surface without
 *  localStorage — SSR, a locked-down embed) do not have to fake globals. */
export declare interface ResumeStorage {
    getItem(key: string): string | null;
    setItem(key: string, value: string): void;
    removeItem(key: string): void;
}

/**
 * How many rows this pane's folder holds — BEFORE the filter row narrows them,
 * which is what "12 items" in the details panel means (`visibleNodes()` is the
 * other question: what is drawn right now).
 */
declare function rowCount(): number;

/**
 * The paths this pane's folder HOLDS — unfiltered, and that is the point.
 *
 * ⚠ Not `visibleNodes()`. The one caller asks "does this row still exist?", and
 * `visibleNodes()` answers "is this row currently drawn?" — two different
 * questions that only agree while the filter row is empty. Answering the first
 * with the second would make typing in the filter box look exactly like a
 * deletion to whoever is asking.
 */
declare function rowPaths(): string[];

/**
 * The S3 access-key surface, as the frontend sees it.
 *
 * Mirrors `model.S3AccessKey` and the connection facts the key endpoints
 * return alongside it. The facts travel WITH the keys on purpose: a key
 * without an endpoint is not a usable credential, and a UI that assembled
 * the URL itself would be a second place to get it wrong (the application
 * URL and the S3 endpoint are different hosts whenever one is configured).
 */
export declare interface S3AccessKey {
    id: number;
    access_key_id: string;
    user_id: number;
    api_token_id?: number | null;
    label: string;
    /** Optional confinement, in the shape S3 clients already understand. */
    bucket?: string;
    prefix?: string;
    created_at: string;
    last_used_at?: string | null;
    expires_at?: string | null;
    /** Set = the key is switched off but still in the audit trail. */
    disabled_at?: string | null;
}

/** Where to point a client, and how to address it. */
export declare interface S3Connection {
    /** Absolute endpoint URL — the S3 host's root, or `<app>/s3`. */
    endpoint: string;
    /** The FILEX_S3 kill switch. False = the operator turned the endpoint off. */
    enabled: boolean;
    /**
     * True when there is no dedicated host, so clients must be told to force
     * path-style addressing. A current SDK defaults to virtual-hosted and then
     * fails at DNS with an error that names neither filex nor the cause.
     */
    path_style: boolean;
}

/** What a freshly minted key returns. The secret appears exactly once. */
export declare interface S3KeyCreated extends S3Connection {
    key: S3AccessKey;
    secret: string;
}

/** What the caller asked for when minting. */
export declare interface S3KeyRequest {
    label: string;
    /** Mint FROM an API token, inheriting its scopes, confinement and expiry. */
    api_token_id?: number;
    bucket?: string;
    prefix?: string;
    expires_at?: string;
}

export declare const S3KeysPanel: DefineComponent<__VLS_Props_22, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
accessKeyID: string;
secret?: string;
endpoint: string;
pathStyle: boolean;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_22> & Readonly<{
onActive?: ((v: {
accessKeyID: string;
secret?: string;
endpoint: string;
pathStyle: boolean;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

/** Matched-in values the search contract allows on a hit. */
export declare type SearchMatched = 'name' | 'content' | 'both';

declare type SelectionMode_2 = 'none' | 'single-file' | 'single-dir' | 'multi';

/**
 * Tier `account`: what `owner` learned about the account behind its
 * credential.
 *
 * `''` is an answer — "this person has not chosen a zone" — and is recorded,
 * so it overrides an older answer from the same page. `null`/`undefined` means
 * "I have no account to speak for" (an `app` token, a failed lookup) and
 * withdraws the entry. A zone the engine rejects is recorded as `''`: the
 * account did say something, and it was not usable.
 *
 * `remember` mirrors the value into `TIMEZONE_ACCOUNT_LS_KEY` for the next
 * first paint, and makes this owner follow that key when another tab changes
 * it. For the admin web app, whose session is always a person.
 */
export declare function setAccountTimeZone(owner: symbol, tz: string | null | undefined, opts?: {
    remember?: boolean;
}): void;

export declare function setColumnHidden(id: ColumnId, hidden: boolean): void;

/** Set a width, clamped to the column's own bounds. */
export declare function setColumnWidth(id: ColumnId, px: number): void;

export declare function setFolderMemoryEnabled(on: boolean): void;

/**
 * Tier `host`: the zone `owner` (an explorer instance) was configured with.
 * `''`/`null`/an engine-rejected id withdraws it — an explorer with no
 * `config.timeZone` has no opinion, and must not hide another one's.
 */
export declare function setHostTimeZone(owner: symbol, tz: string | null | undefined): void;

/** Set (or clear back to default) a user override. '' unbinds. */
export declare function setShortcutOverride(id: string, combo: string): void;

export declare function setTheme(id: string): void;

export declare function setThemeMode(mode: ThemeModePref): void;

/** Set (or, with `''`, clear) the viewer's own choice in this browser. */
export declare function setViewerTimeZone(tz: string): void;

export declare interface ShareInfo {
    uuid: string;
    url: string;
    password_pin?: string | null;
    expires_at?: string | null;
    /** True when the server shortened (or set) the expiry to honour its
     *  max-TTL setting — the UI then shows the real date, not the request. */
    expiry_clamped?: boolean;
    max_downloads?: number | null;
    downloads?: number;
    created_at?: string;
}

/** Registry order = help/settings display order. */
export declare const SHORTCUT_ACTIONS: ShortcutActionDef[];

/** One remappable action in the shortcut registry. */
export declare interface ShortcutActionDef {
    /** Stable id — also the localStorage override key. */
    id: string;
    /** Default combo in canonical form. */
    defaultCombo: string;
    /**
     * Extra built-in combos that also trigger the action but are NOT
     * remappable (e.g. Backspace on go-up, which carries the
     * selection-dependent dual behaviour). Shown in the help sheet and
     * reserved in conflict detection.
     */
    fixedCombos?: string[];
    labelKey: string;
    groupKey: string;
    /** false → the combo can't be remapped (Esc). Default true. */
    customizable?: boolean;
    /** false → don't preventDefault on match (Enter / Esc). Default true. */
    prevent?: boolean;
    /** true → fires even when focus sits in a form control (Esc). */
    inForms?: boolean;
}

export declare interface ShortcutConflict {
    id: string;
    /** true → the clash is with a fixed (non-remappable) combo. */
    fixed: boolean;
}

export declare interface ShortcutHandlers {
    onDelete?: () => void;
    onRename?: () => void;
    onSelectAll?: () => void;
    onCut?: () => void;
    onCopy?: () => void;
    onPaste?: () => void;
    onOpen?: () => void;
    onClose?: () => void;
    onFocusSearch?: () => void;
    onDuplicate?: () => void;
    onPathJump?: () => void;
    onGoUp?: () => void;
    onShowHelp?: () => void;
    onToggleInspector?: () => void;
    onToggleHidden?: () => void;
    onStar?: () => void;
    onQuickLook?: () => void;
    onTabNew?: () => void;
    onTabClose?: () => void;
    onTabNext?: () => void;
    onTabPrev?: () => void;
    onNewFolder?: () => void;
    onUpload?: () => void;
    onRefresh?: () => void;
    onDownload?: () => void;
    onPreview?: () => void;
    onShare?: () => void;
    onTags?: () => void;
    onConvert?: () => void;
    onOpenTab?: () => void;
    onCopyPath?: () => void;
    onCopyId?: () => void;
    onRestore?: () => void;
    hasSelection?: () => boolean;
}

/**
 * The one way a hint may name a key.
 *
 * ⚠ Never write a key into a hint by hand — not in a template, not in a
 * locale string. Every combo in this registry is remappable, so a
 * hardcoded "Ctrl+K" is true only until someone opens the shortcut
 * settings, and then it is a label that tells the user to press a key
 * that does nothing. Call this instead and interpolate the result;
 * `web/tests/ui/shortcutHints.test.ts` fails the build on a literal.
 *
 * Returns '' when the action is unbound, so a caller can drop the whole
 * segment rather than print an empty key cap.
 */
export declare function shortcutHint(id: string): string;

export declare const ShortcutSettings: DefineComponent<__VLS_Props_11, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
}, string, PublicProps, Readonly<__VLS_Props_11> & Readonly<{
onClose?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface ShortcutView {
    id: string;
    /** Current (possibly remapped) combo, '' = unbound. */
    combo: string;
    /** Non-remappable extra combos (display + reservation only). */
    fixedCombos: string[];
    /** Display combos: [combo, ...fixedCombos] minus empties. */
    keys: string[];
    labelKey: string;
    groupKey: string;
    customizable: boolean;
    overridden: boolean;
}

declare type SizeFilter = 'any' | 'lt1' | '1to10' | '10to100' | 'gt100' | 'range';

/**
 * Snippet segment parser — the search backend returns content snippets as
 * PLAIN TEXT with matched words wrapped in «guillemets» (contract: no HTML
 * ever crosses the wire). The UI renders highlights by splitting the string
 * into segments and emitting each one as a TEXT node (a <mark> wrapper for
 * matches) — never via innerHTML, so a file whose content contains markup
 * can't inject anything into the page.
 */
export declare interface SnippetSegment {
    /** Literal text of this segment. Always rendered as a text node. */
    text: string;
    /** True when the segment was «wrapped» — render inside <mark>. */
    match: boolean;
}

/**
 * Split a `«»`-annotated snippet into render segments. An unpaired `«`
 * degrades gracefully: the rest of the string is treated as plain text.
 */
export declare function snippetSegments(snippet: string): SnippetSegment[];

declare type SortDir = 'asc' | 'desc';

declare type SortKey = 'name' | 'type' | 'modified' | 'size';

/** Split `adapter://rel` into its two halves; a bare path has no adapter. */
export declare function splitWire(p: string): [string, string];

/** Where an SSH client should connect, and as whom. */
export declare interface SSHConnection {
    /** The FILEX_SFTP kill switch. False = the operator turned the port off. */
    enabled: boolean;
    host: string;
    /**
     * ⚠ Not 22 and not the web port. SFTP is raw TCP on a port of its own, and
     * a guide that printed 443 would send every client at a proxy that speaks
     * only HTTP.
     */
    port: number;
    /** The login name: the account's username, or its e-mail when it has none. */
    login: string;
    /** The FTPS endpoint, reported by the same call. */
    ftps?: FTPSFacts;
}

export declare const SSHKeysPanel: DefineComponent<__VLS_Props_23, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
host: string;
port: number;
login: string;
enabled: boolean;
hasKey: boolean;
ftps?: FTPSFacts;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_23> & Readonly<{
onActive?: ((v: {
host: string;
port: number;
login: string;
enabled: boolean;
hasKey: boolean;
ftps?: FTPSFacts;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/**
 * The SSH key surface, as the frontend sees it.
 *
 * Mirrors `model.SSHPublicKey` plus the connection facts the endpoint returns
 * with it — the host, the port and the LOGIN NAME, which is the piece people
 * most often get wrong when they type it themselves.
 */
export declare interface SSHPublicKey {
    id: number;
    user_id: number;
    name: string;
    /** SHA256 fingerprint, base64, without the `SHA256:` prefix. */
    fingerprint: string;
    /** The normalised wire form, `<type> <base64>`. */
    public_key: string;
    created_at: string;
    last_used_at?: string | null;
    /** Set = the key is switched off but still listed. */
    disabled_at?: string | null;
}

export declare const StarButton: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (message: string) => any;
change: (value: boolean) => any;
}, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{
onError?: ((message: string) => any) | undefined;
onChange?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;

/**
 * A driver's runtime feature set, from `backend/internal/storage.Capabilities`.
 *
 * ⚠ `range` was missing from BOTH hand-written copies of this (here and in
 * web/src/api/types.ts) while the server has always sent it — the exact way a
 * type re-declared per package drifts from the struct it describes.
 */
export declare interface StorageDriverCapabilities {
    read?: boolean;
    /** Ranged reads: the difference between 206/Content-Range and a whole-object copy. */
    range?: boolean;
    write?: boolean;
    move?: boolean;
    copy?: boolean;
    delete?: boolean;
    mkdir?: boolean;
    presign?: boolean;
    watch?: boolean;
}

export declare interface StorageDriverDescriptor {
    driver: string;
    label: string;
    i18n_key: string;
    fields: StorageField[];
    capabilities: StorageDriverCapabilities;
}

/** One config key of a storage driver, as declared by the driver itself. */
export declare interface StorageField {
    key: string;
    type: StorageFieldType;
    /** English fallback label — used only when `i18n_key` is missing from
     *  the catalogue, so a driver released after this build still renders
     *  readable labels instead of raw keys. */
    label: string;
    help?: string;
    i18n_key: string;
    help_i18n_key?: string;
    required: boolean;
    /** Credential material: render masked, never log, never put in a URL. */
    secret: boolean;
    default?: unknown;
    placeholder?: string;
    options?: StorageFieldOption[];
    min?: number;
    max?: number;
    monospace?: boolean;
    multiline?: boolean;
    advanced?: boolean;
    /** THE field that scopes the storage inside the backend (s3 prefix,
     *  local path, sftp/ftp/webdav root). The backend rejects an empty or
     *  "/" value with ROOT_PATH_FORBIDDEN. */
    root?: boolean;
    /** Legacy spellings the driver still reads for this field. */
    aliases?: string[];
}

export declare interface StorageFieldOption {
    value: string;
    /** English fallback; `i18n_key` wins when the catalogue has it. */
    label: string;
    i18n_key?: string;
}

export declare const StorageFields: DefineComponent<__VLS_Props_20, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (v: Record<string, unknown>) => any;
}, string, PublicProps, Readonly<__VLS_Props_20> & Readonly<{
"onUpdate:modelValue"?: ((v: Record<string, unknown>) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

/**
 * Connections — the shapes the storage-connection surface works with.
 *
 * Every one of these mirrors something the BACKEND declares, on purpose.
 * `StorageField` / `StorageDriverDescriptor` are the wire form of
 * `backend/internal/storage/descriptor.go`, served by
 * `GET /api/admin/storage-drivers`: a driver states its own config keys,
 * their types, which one is the storage root and which hold credentials,
 * and every surface renders that one declaration.
 *
 * The alternative — a form per surface — is exactly what shipped broken:
 * three of the four drivers the admin UI offered could not be created
 * through it because the form collected keys the backend never read. A
 * second hand-written form in the desktop app would have been a fourth
 * copy of the same mistake.
 */
export declare type StorageFieldType = 'string' | 'int' | 'bool' | 'password' | 'select';

/** A configured storage, as `GET /api/admin/storages` returns it. */
export declare interface StorageRow {
    id: number;
    name: string;
    driver: string;
    enabled: boolean;
    read_only: boolean;
    config: Record<string, unknown>;
    rbac_enabled?: boolean;
    sync_mode?: string;
    created_at?: string;
    updated_at?: string;
    stats?: {
        file_count?: number;
        total_size_bytes?: number;
    };
}

export declare interface StorageTestResult {
    ok: boolean;
    error?: string;
    object_count?: number;
    sample_listing?: unknown[];
}

/** POST/PATCH body for a storage. */
export declare interface StorageWrite {
    name: string;
    driver: string;
    config: Record<string, unknown>;
    read_only?: boolean;
    enabled?: boolean;
}

declare type Store = Record<string, ResumeRecord>;

/** Every zone the engine knows, sorted; the fallback list when it knows none. */
export declare function supportedTimeZones(): string[];

/**
 * Create/update/empty the singleton `<style data-filex-theme>` element in
 * <head>. Idempotent — safe to call from every explorer instance.
 */
export declare function syncThemeStyle(id: string): void;

export declare const TabBar: DefineComponent<__VLS_Props_14, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: (id: string) => any;
select: (id: string) => any;
"toggle-inspector": () => any;
new: () => any;
reorder: (from: number, to: number) => any;
"toggle-split": () => any;
}, string, PublicProps, Readonly<__VLS_Props_14> & Readonly<{
onClose?: ((id: string) => any) | undefined;
onSelect?: ((id: string) => any) | undefined;
"onToggle-inspector"?: (() => any) | undefined;
onNew?: (() => any) | undefined;
onReorder?: ((from: number, to: number) => any) | undefined;
"onToggle-split"?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare interface TabItem {
    id: string;
    label: string;
    /** true → the tab carries a split pane (small accent dot). */
    split: boolean;
}

/** What one table looks like right now: which optional columns are drawn, how
 *  wide every track is, and how wide the table therefore is. */
export declare interface TableLayout {
    /** The optional columns, in the person's order. Never shortened for width. */
    visible: ColumnId[];
    /** Every drawn track's width in px, Name included. */
    widths: Record<ColumnId, number>;
    /** The table's own width: every track, every gap, both paddings. */
    total: number;
    /** True while these widths are derived from the pane rather than stored. */
    auto: boolean;
}

/**
 * THE TABLE'S WIDTHS — one answer, used by the header and by every row.
 *
 * ⚠⚠ This replaces `fitColumns`, and the difference is not a tuning. That pass
 * fitted the columns TO the container and dropped one whenever they stopped
 * fitting; the header menu then told the person there was "no room". The owner
 * rejected the whole model, verbatim: "no room demesin, kenara devam eden bir
 * scroll getirsin… tablo vertical ve horizontal scrollable olarak açılacak,
 * genişletildikçe no room olmasın." So:
 *
 *   · nothing is ever dropped for want of room — `visible` is the person's
 *     choice and the caller's candidates, and width has no vote;
 *   · the table's width is the SUM of its columns, so when that exceeds the
 *     pane the table scrolls sideways (the view's job) instead of shrinking;
 *   · Name is an ordinary column with a width of its own, so narrowing Size no
 *     longer widens Name.
 *
 * ⚠ `candidates` is what the CALLER is willing to draw at all: Location is
 * only meaningful where rows come from more than one folder, and the star only
 * where starring is offered. Passing them is how those two facts stay with the
 * component that knows them instead of being re-derived here.
 *
 * ⚠⚠ AUTO vs STORED, which is the only subtle thing left. With nothing stored
 * (`widthsAreAuto`), the widths are derived from the pane so a table nobody has
 * configured opens sensibly at 1440 and at 390 alike: Name asks for `NAME_AUTO`,
 * the other columns give up room toward their own minimums to pay for it, and
 * Name takes any slack that is left. The instant one width is stored — and the
 * view stores ALL of them on the first drag, see `freezeWidths` — the pane
 * stops having an opinion and these are the person's numbers, at every window
 * size, forever. Without that line a resize would be silently undone by the
 * next auto-fit, which is the trap this pair exists to avoid.
 */
export declare function tableLayout(available: number, candidates: readonly ColumnId[], opts?: {
    gap?: number;
    padding?: number;
}): TableLayout;

export declare type TabsApi = ReturnType<typeof useTabs>;

/** Per-tab split state — the secondary pane's own location. */
export declare interface TabSplit {
    path: string;
    /** ui-fix — the pane's OWN view mode (list/grid/gallery); undefined
     *  inherits the main panel's mode at split time. */
    viewMode?: ViewMode;
}

export declare interface TabState {
    id: string;
    /** Location snapshot in `currentPath` form (see module docs). */
    path: string;
    viewMode: ViewMode;
    split: TabSplit | null;
}

export declare const TagPicker: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (message: string) => any;
open: (tag: string) => any;
change: (tags: string[]) => any;
}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
onError?: ((message: string) => any) | undefined;
onOpen?: ((tag: string) => any) | undefined;
onChange?: ((tags: string[]) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

/**
 * ⚠⚠ `filex.palette`, NOT `filex.theme` — and the rename is a BUG FIX, not
 * tidying.
 *
 * `web/src/lib/theme.ts` has always stored the admin app's light/dark/auto
 * MODE under `filex.theme`, and this module stored the PALETTE id under the
 * same name. Two writers, one key, neither aware of the other — and because
 * both readers fall back silently on a value they do not recognise, nothing
 * ever threw: picking "Night Blue" in the explorer reset the panel's
 * light/dark choice to auto, and choosing Dark in the panel reset the palette
 * to default. It went unseen for as long as the two controls lived on
 * opposite sides of the product; putting them both in the settings modal
 * makes it a one-click round trip.
 */
export declare const THEME_LS_KEY = "filex.palette";

export declare const THEME_MODE_LS_KEY = "filex.thememode";

export declare function themeById(id: string | null | undefined): ThemeDef | undefined;

export declare interface ThemeDef {
    /** Stable id — persisted in localStorage, never shown to users. */
    id: string;
    /** i18n catalogue key for the display name (tr + en). */
    nameKey: string;
    /** Palette applied when the resolved mode is light. */
    light: ThemeTokenMap;
    /** Palette applied when the resolved mode is dark. */
    dark: ThemeTokenMap;
}

export declare const ThemeGallery: DefineComponent<__VLS_Props_8, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
select: (id: string) => any;
mode: (mode: ThemeModePref) => any;
}, string, PublicProps, Readonly<__VLS_Props_8> & Readonly<{
onClose?: (() => any) | undefined;
onSelect?: ((id: string) => any) | undefined;
onMode?: ((mode: ThemeModePref) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare type ThemeMode = 'light' | 'dark' | 'auto';

/**
 * The user's own light/dark choice — a different question from WHICH theme
 * paints (that is `themeId` above).
 *
 * `'host'` is the default and means "whatever the embedder passed in
 * `config.theme`". That is what keeps every existing embed unchanged: work and
 * the fishapp hand the explorer the mode their own page is in, and an explorer
 * that silently overrode it would sit as a dark rectangle inside a light page.
 * The other three are an explicit choice by the person looking at it and
 * outrank the host: `'auto'` follows the operating system, `'light'`/`'dark'`
 * are fixed.
 */
export declare type ThemeModePref = 'host' | 'auto' | 'light' | 'dark';

export declare const ThemePalette: DefineComponent<__VLS_Props_9, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (id: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_9> & Readonly<{
onSelect?: ((id: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/**
 * ⚠⚠ Every theme declares the SAME key set, and there is a test for it
 * (`web/tests/api/themeTokenParity.test.ts`). That test exists because of a
 * bug whose whole nature is that nothing notices:
 *
 *   `--fe-primary-soft` was declared by variables.css and used by nine rules
 *   in base.css — the active tab of a segmented control, a filter chip that is
 *   set, an active toolbar button, the advanced-search tabs — and by NO theme
 *   map at all. So somebody on Forest, Amber or Lilac got their palette
 *   everywhere except the one token that marks "this is the selected thing",
 *   which stayed stock blue and clashed with the palette they had just picked.
 *   `--fe-border-soft` (ten rules, the quieter separators inside panels) was
 *   missing the same way. Neither errored, neither looked broken in the
 *   gallery card, and the only way to see it was to pick a theme and look.
 *
 * How the two are derived, so a new theme fills them the same way:
 *
 *   --fe-primary-soft = the theme's OWN primary mixed into its OWN background,
 *     at the fraction that reproduces the STOCK tint's separation from its
 *     background (1.184:1 light, 1.207:1 dark). Separation is the invariant,
 *     not the mix fraction: the palettes' primaries run from a near-black
 *     green to a pale grey, so a fixed 13% lands anywhere between invisible
 *     and a slab. Held that way, every palette's tint reads with the same
 *     weight as the stock one. Measured: text on it is 9.44:1 (Terminal dark)
 *     to 17.85:1 (High Contrast light), so the 4.5 bar is never in question.
 *   --fe-border-soft = the theme's own border mixed toward its own background
 *     at the stock fraction (0.60 light / 0.68 dark), which reproduces the
 *     stock value exactly. ⚠ High Contrast is the deliberate exception: it
 *     takes its own `--fe-border` unchanged, because a *soft* separator is the
 *     one thing that theme exists to not have.
 *
 * ⚠ What is deliberately NOT themed, and why:
 *   `--fe-ok` / `--fe-warning` / `--fe-keep-ok` — status signals, not taste.
 *     They are identical in light and dark on purpose; "ok" that is green in
 *     one palette and amber in another stops being a signal.
 *   `--fe-icon-*` — file-type accents. A PDF is red and a folder is yellow in
 *     every palette, and they are never the only cue (the row carries its name
 *     in `--fe-text` too).
 *   radii, control heights, the type scale, gaps, `--fe-sidenav-w`,
 *     `--fe-font-mono` — metrics, not a palette.
 *   `--fe-shadow` / `--fe-shadow-sm` / `--fe-font` — depth and face rather
 *     than colour, and the two themes that DO override them (High Contrast's
 *     hard 1px outlines, Terminal's monospace face) are extras on top of the
 *     shared set, not holes in it. The parity test allows extras and requires
 *     the shared set.
 */
export declare const THEMES: ThemeDef[];

/** Map of `--fe-*` custom property → value. */
export declare type ThemeTokenMap = Record<string, string>;

/**
 * ⚠⚠ THE order. First tier holding a valid zone wins; `device` always holds
 * one. Flipping a ranking is a change to this array and to nothing else — the
 * resolver, the explorer, the web app and the embed's own dialog all read it
 * (pinned by web/tests/lib/timeZoneTiers.test.ts).
 *
 * `viewer` is on top, above the embedder the owner numbered "1", and that is a
 * judgement rather than a transcription:
 *
 *   - A host's `config.timeZone` is a DEFAULT it chooses for everybody who
 *     visits, written before any of them arrived. A viewer's pick is a
 *     decision one person made on purpose, afterwards, in a control that
 *     exists for nothing else. If the host outranked it, every host that sets
 *     a zone would ship an embed whose Time zone control visibly does nothing
 *     — and a control that saves, reads back and changes nothing is worse than
 *     no control.
 *   - The explorer already ranks the same two things this way for the theme
 *     mode: `config.theme` is what `'host'` (never chosen) resolves to, and
 *     the first click in the gallery pins the viewer's own choice above it
 *     (FileExplorer.vue, `themeMode`). One product, one answer to "does the
 *     host or the person decide how this looks".
 *   - The pick is cheap to undo: the picker's first row is "use the default",
 *     and that row names the zone and the tier it falls back to.
 *
 * Below the viewer, the owner's own numbering stands as given.
 */
export declare const TIME_ZONE_TIERS: readonly TimeZoneTier[];

/**
 * localStorage key of the web app's copy of the ACCOUNT tier, so the first
 * paint after a reload is already right instead of flashing the device's zone
 * until `/api/auth/me` lands. Written only by a host that opts in
 * (`setAccountTimeZone(…, { remember: true })`) — an embed on a shared origin
 * must not inherit the zone of whoever last signed in to something else there.
 */
export declare const TIMEZONE_ACCOUNT_LS_KEY = "filex.timezone";

/**
 * localStorage key of the VIEWER tier — the embed's own setting.
 *
 * ⚠ Not `filex.timezone`. That key already holds the web app's copy of the
 * ACCOUNT's zone in every browser that has opened the admin app, and reading
 * it as a viewer choice would rank a stale cache above the account forever: a
 * zone changed in another browser would never arrive in this one.
 */
export declare const TIMEZONE_VIEWER_LS_KEY = "filex.timezone.viewer";

export declare const TimeZonePicker: DefineComponent<__VLS_Props_10, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (v: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_10> & Readonly<{
"onUpdate:modelValue"?: ((v: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
inputEl: HTMLInputElement;
listEl: HTMLUListElement;
}, any>;

/** A value per tier. Empty, missing or engine-rejected means "no opinion". */
export declare type TimeZoneSources = Partial<Record<Exclude<TimeZoneTier, 'device'>, string | null>>;

/** What each tier currently holds (`''` = nothing). Reactive. */
export declare function timeZoneSources(): Required<TimeZoneSources>;

/**
 * The places a zone can come from.
 *
 *   viewer  — the person looking at this page picked one in THIS browser
 *             (the explorer's "⋯" → Time zone). localStorage, per origin.
 *   host    — the embedder set `config.timeZone` on the explorer.
 *   account — the account behind the credential, from `GET /api/auth/me`, and
 *             ONLY when that credential is a person's (a cookie session or
 *             their own API key). An `app` token is shared by every visitor of
 *             the embed that holds it, so its owner's zone is nobody's clock
 *             and the tier is skipped.
 *   device  — the browser's own zone, resolved live by `Intl`.
 */
export declare type TimeZoneTier = 'viewer' | 'host' | 'account' | 'device';

/** Seconds or milliseconds — the backend has sent both. Normalised once. */
declare function toDate(ms: number | undefined | null): Date | null;

export declare const TokensPanel: DefineComponent<__VLS_Props_25, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
hasToken: boolean;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_25> & Readonly<{
onActive?: ((v: {
hasToken: boolean;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

/**
 * Mark a remembered folder as used, for the LRU clock — and ONLY if it is
 * already remembered. Called on navigation.
 *
 * ⚠ The guard is the point. Bumping an absent key would create an entry for
 * every folder anyone ever opens, which is the unbounded growth the cap exists
 * to survive; keeping the guard means the cap is a safety net rather than a
 * working limit.
 */
export declare function touchFolder(key: string): void;

/** Turkish UI strings. */
export declare const tr: Record<string, string>;

/**
 * connectionGuides — "how do I connect to this thing?", generated from the
 * live deployment instead of written as prose.
 *
 * A published document says `https://fm.example.com/dav/` and leaves the
 * reader to substitute three values, one of which (their own username) they
 * usually get wrong. What ships here is the real host, the real storage
 * name and the caller's own credential, with a copy button — which is the
 * difference between a doc and a working paste. No surveyed product
 * (Backblaze, R2, Storj, MinIO, Garage) does this; it is the cheapest win
 * on the whole surface.
 *
 * Shape of the thing: a protocol is a `GuideBuilder` registered in
 * `GUIDE_BUILDERS`. WebDAV is built here because WebDAV is what filex
 * serves today; S3 and SFTP are a builder each and a registry line when
 * their servers land — no second implementation, no second UI.
 *
 * The commands are not invented. They are the ones verified on 2026-08-14
 * and written down in `docs/WEBDAV.md` and §13.5 of the write-path
 * handover, including the three Windows registry limits that otherwise
 * look exactly like filex bugs.
 */
export declare type Translate = (key: string, vars?: Record<string, string | number>) => string;

/** A soft-deleted node as returned by the filex trash listing endpoint. */
declare interface TrashEntry {
    id: number;
    storage_id: number;
    storage_name?: string;
    path: string;
    name: string;
    size: number;
    mime?: string;
    deleted_at: string;
    ttl_days?: number | null;
}

/**
 * Navigate to `url` in a way that saves a file instead of moving the page.
 *
 * Exported separately from `downloadArchive` so a caller that already has a
 * ticket (a retry, a test) can trigger it, and so the DOM half can be replaced
 * in an environment that has no document.
 */
export declare function triggerFileNavigation(url: string, doc?: Document): void;

declare type TypeFilter = 'any' | 'folder' | 'document' | 'spreadsheet' | 'presentation' | 'pdf' | 'image' | 'video' | 'audio' | 'archive' | 'code';

/** Both of them, as data — so a doc, a test and a resolver cannot disagree
 *  about how many there are. */
export declare const UI_PROFILES: readonly UiProfile[];

/**
 * uiProfile — how much of the explorer to draw. Two names, and one rule for
 * everything that is not one of them.
 *
 * ⚠⚠ The profile is a REDUCTION switch, never a LOOK switch. The shell — the
 * header with its one search field, the filter row, "+ New", the Folders /
 * Files sections, the info panel's tabs, the storage line — is what filex IS;
 * nothing reads a profile to decide whether to draw it. `'simple'` turns OFF
 * the tab strip, the split pane, the gallery view mode and the panel's
 * "How to connect" / "API keys" entries, and removes nothing from the build.
 *
 * ⚠⚠ WHY THERE IS A RESOLVER AND NOT A UNION CHECK AT EACH CALL SITE. This
 * value comes from OUTSIDE: a `config` object typed by an embedder who may not
 * use TypeScript at all, or a `ui-profile="…"` attribute on a custom element,
 * which is a string the DOM will hand over unexamined. So "what does an
 * unrecognised value mean" is a real question with real users behind it, and
 * it is answered here, once, instead of by whatever each reader's `===` chain
 * happened to fall through to.
 *
 * THE ANSWER: `'simple'` and nothing else turns the reduction on. Every other
 * value — `'standard'`, `undefined`, a typo, a name a later version knows and
 * this one does not — is `'standard'`, the documented default, and a string we
 * did not recognise is said out loud once in the console.
 *
 * ⚠ WHICH RETIRES `'drive'`, deliberately and with its cost stated. It shipped
 * as a third profile in v0.32.0 and became an alias of `'simple'` in v0.40.0;
 * the owner's ruling on 2026-09-13 was to take it out ("kaldıralım direk").
 * filex is open source, so an embed somewhere may still be passing it, and
 * what that embed gets is now the FULL explorer rather than the reduced one —
 * it gains the tab strip, the split pane, the gallery mode and the connection
 * guides. That is a visible change in one direction and a one-word fix
 * (`uiProfile: 'simple'`), and it is the honest one: mapping the retired name
 * onto `'simple'` here would be the alias again, wearing a resolver's coat,
 * and it would also mean a plain typo silently REDUCED somebody's UI — a
 * failure that looks like features going missing and points at nothing. The
 * console line names the value so the fix takes a search rather than a bisect.
 */
/** The two profiles. There is no third, and no alias of either. */
export declare type UiProfile = 'standard' | 'simple';

/**
 * Unlock with the installation escrow private key.
 *
 * Returns null when the folder has no escrow slot — which is the case for
 * every folder created while escrow was off, and is why escrow cannot be
 * turned on retroactively.
 */
export declare function unlockWithEscrowKey(marker: E2eMarker, privateKey: CryptoKey): Promise<CryptoKey | null>;

/**
 * Unlock with the folder password. Returns the FMK (the key `decryptFile`
 * wants) or null when the password is wrong.
 */
export declare function unlockWithPassword(marker: E2eMarker, password: string): Promise<CryptoKey | null>;

/**
 * Unlock with the user recovery key shown when the folder was created.
 * Returns null for a malformed key, a wrong key, or a folder that has no
 * recovery slot at all — the caller cannot tell those apart, and neither can
 * an attacker.
 */
export declare function unlockWithRecoveryKey(marker: E2eMarker, recoveryKey: string): Promise<CryptoKey | null>;

/**
 * Give an existing v1 folder recovery keys, in place and without rewriting a
 * single file.
 *
 * The v1 files are wrapped under the password KEK, so the FMK stays defined
 * as "the KEK" (`fmk: 'kek'`) and the new slots wrap those raw bytes. The
 * password path afterwards is byte-identical to what it was.
 *
 * ⚠ Requires the password — this is only callable at the one moment filex
 * ever has it. There is no way to give a v1 folder recovery without it.
 * ⚠ When the installation has escrow on, this ALSO hands the operator a key
 * to a folder that did not have one. The caller must say so before asking.
 */
export declare function upgradeMarkerV1(marker: E2eMarker, password: string, opts?: CreateFolderOptions): Promise<CreatedFolder>;

export declare interface UploadFinalizeResponse {
    s3Key: string;
    url?: string;
}

/** Identity of one (destination, file) pair. */
export declare function uploadFingerprint(path: string, file: {
    name: string;
    size: number;
    lastModified?: number;
}): string;

export declare interface UploadInitResponse {
    uploadId: string;
    parts: Array<{
        partNumber: number;
        presignedUrl: string;
    }>;
    expiresAt: string;
    s3Key?: string;
}

export declare interface UploadJob {
    id: string;
    file: File;
    path: string;
    /** Server-side staged upload id, once `begin` has answered. */
    uploadId?: string;
    totalBytes: number;
    /** Bytes filex has acknowledged (plus the chunk currently in flight). */
    uploadedBytes: number;
    percent: number;
    status: 'pending' | 'initializing' | 'uploading'
    /** Every byte is in filex; the commit is being accepted. */
    | 'committing'
    /** Committed and listed; the ops worker is writing it to the backend. */
    | 'transferring' | 'done' | 'error' | 'aborted';
    /** Byte offset an interrupted session was picked up from, when it was. */
    resumedFrom?: number;
    /** Background transfer op, once the commit is accepted. */
    opId?: number;
    nodeId?: number;
    error?: string;
    cancel(): void;
}

export declare interface UploadLimits {
    max_upload_mb: number;
}

export declare interface UploadOptions {
    path: string;
    file: File;
    chunkSize?: number;
    onProgress?: (job: UploadJob) => void;
    onDone?: (job: UploadJob, result: UploadResult) => void;
    onError?: (job: UploadJob, err: Error) => void;
    /**
     * Wait for the backend transfer before resolving. Defaults to TRUE, because
     * "the server has the bytes" and "the storage has the bytes" are different
     * claims and only the second one is an upload.
     *
     * ⚠ It used to default to false and no caller ever set it, so the job went
     * straight to `done` on the 202 — a transfer that failed afterwards in the
     * ops worker left the user looking at a finished upload for a file that was
     * never stored (issue #16: every file over the chunk threshold, on every S3
     * backend). The `transferring` phase is short for a healthy storage and is
     * the only place a failure can still be shown, so it is the default; pass
     * false to opt out where the wait is genuinely unwanted.
     */
    waitForTransfer?: boolean;
}

/** What `commit` answers, plus the fields a caller wants afterwards. */
export declare interface UploadResult {
    id: string;
    op_id?: number;
    node_id?: number;
    path?: string;
    transfer_state?: string;
}

export declare function useConnections(config: ExplorerConfig): {
    drivers: ShallowRef<StorageDriverDescriptor[], StorageDriverDescriptor[]>;
    driverNames: ComputedRef<string[]>;
    storages: ShallowRef<StorageRow[], StorageRow[]>;
    visible: ShallowRef<string[], string[]>;
    me: Ref<    {
    id: number;
    email: string;
    display_name?: string | undefined;
    role?: string | undefined;
    } | null, ConnectionsUser | {
    id: number;
    email: string;
    display_name?: string | undefined;
    role?: string | undefined;
    } | null>;
    publicUrl: Ref<string | null, string | null>;
    loading: Ref<boolean, boolean>;
    loaded: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    canManage: Ref<boolean | null, boolean | null>;
    denial: Ref<ManageDenial | null, ManageDenial | null>;
    load: () => Promise<void>;
    createStorage: (body: StorageWrite) => Promise<StorageRow>;
    updateStorage: (id: number, body: Partial<StorageWrite>) => Promise<StorageRow>;
    deleteStorage: (id: number) => Promise<void>;
    testStorage: (body: {
        driver: string;
        config: Record<string, unknown>;
    }) => Promise<StorageTestResult>;
    descriptor: (driver: string) => StorageDriverDescriptor | undefined;
    fields: (driver: string) => StorageField[];
    defaults: (driver: string) => Record<string, unknown>;
    missingRequired: (driver: string, cfg: Record<string, unknown>) => StorageField[];
};

export declare function useFileApi(config: ExplorerConfig): {
    wsTicket: () => Promise<{
        ticket: string;
        ws_url: string;
    } | null>;
    index: (path: string) => Promise<ManagerResponse>;
    search: (path: string, filter: string) => Promise<ManagerResponse>;
    globalSearch: (query: string, opts?: {
        limit?: number;
        scope?: GlobalSearchScope;
    }) => Promise<GlobalSearchHit[]>;
    quotaMe: () => Promise<QuotaSnapshot | null>;
    subfolders: (path: string) => Promise<{
        folders: FileNode[];
    }>;
    newFolder: (path: string, name: string) => Promise<ManagerResponse>;
    newFile: (path: string, name: string, type: string) => Promise<NewFileResponse>;
    rename: (path: string, item: string, name: string) => Promise<ManagerResponse>;
    move: (path: string, items: string[], target: string) => Promise<ManagerResponse>;
    copy: (source: string[], target: string) => Promise<{
        op: PendingOpDto;
    }>;
    moveAsync: (source: string[], target: string, sourceDir?: string) => Promise<{
        op: PendingOpDto;
    }>;
    deleteAsync: (source: string[], sourceDir?: string) => Promise<{
        op: PendingOpDto;
    }>;
    deleteItems: (path: string, items: string[]) => Promise<ManagerResponse>;
    restore: (source: string[]) => Promise<{
        ok: boolean;
        restored: number;
    }>;
    listTrash: (storageName?: string) => Promise<{
        entries: TrashEntry[];
        total: number;
    }>;
    restoreIds: (ids: number[]) => Promise<{
        restored: number;
        taken: string[];
    }>;
    uploadMultipart: (path: string, files: File[], onProgress?: (p: number) => void) => Promise<ManagerResponse>;
    downloadUrl: (path: string) => string;
    previewUrl: (path: string) => string;
    fetchBlob: (path: string, opts?: {
        fresh?: boolean;
    }) => Promise<{
        url: string;
        blob: Blob;
        mime: string;
    }>;
    fetchArrayBuffer: (path: string) => Promise<ArrayBuffer>;
    limits: () => Promise<UploadLimits>;
    capabilities: () => Promise<Capabilities>;
    e2eEscrowChallenge: (path: string) => Promise<{
        id: string;
        challenge: string;
        kid: string;
    }>;
    e2eEscrowUsed: (payload: {
        path: string;
        id: string;
        nonce: string;
    }) => Promise<{
        ok: boolean;
        notified: boolean;
    }>;
    createShare: (payload: {
        path: string;
        password?: boolean;
        expires_at?: string | null;
        max_downloads?: number | null;
        kind?: string;
        max_uploads?: number | null;
        drop_settings?: Record<string, unknown> | null;
    }) => Promise<{
        share: ShareInfo & {
            url: string;
            path: string;
            filename: string;
            kind?: string;
        };
    }>;
    listShares: (path: string) => Promise<{
        shares: ShareInfo[];
    }>;
    revokeShare: (uuid: string) => Promise<{
        success: boolean;
    }>;
    archiveList: (path: string) => Promise<{
        entries: ArchiveEntry[];
    }>;
    archiveExtract: (path: string, members?: string[]) => Promise<{
        keys: string[];
        count: number;
    }>;
    archiveAdd: (path: string, files: Array<{
        name: string;
        source: string;
    }>) => Promise<{
        path: string;
    }>;
    listVersions: (nodeId: number) => Promise<NodeVersion[]>;
    restoreVersion: (nodeId: number, versionId: number, snapshotCurrent?: boolean) => Promise<void>;
    snapshotVersion: (nodeId: number) => Promise<void>;
    listComments: (nodeId: number) => Promise<NodeComment[]>;
    addComment: (nodeId: number, body: string) => Promise<NodeComment>;
    deleteComment: (id: number) => Promise<void>;
    listPermissions: (path: string) => Promise<PermissionsResponse>;
    resolveEmail: (email: string) => Promise<ResolveEmailResponse>;
    searchUsers: (q: string) => Promise<UserSearchResponse>;
    addPermission: (body: {
        path: string;
        user_id: number;
        level: string;
        is_dir?: boolean;
    }) => Promise<unknown>;
    updatePermission: (id: number, level: string) => Promise<unknown>;
    deletePermission: (id: number) => Promise<unknown>;
    invitePermission: (body: {
        path: string;
        email: string;
        level: string;
        create_user?: boolean;
        role?: string;
        is_dir?: boolean;
        locale?: string;
    }) => Promise<InviteResponse>;
    shareMail: (body: {
        path: string;
        email?: string;
        emails?: string[];
        url: string;
        pin?: string | null;
        expires_days?: number;
        locale?: string;
        is_dir?: boolean;
        size?: number;
        mode?: string;
    }) => Promise<{
        emailed: boolean;
        sent?: string[];
        failed?: string[];
    }>;
    endpoints: EndpointMap;
    authHeaders: (extra?: Record<string, string>) => Promise<Record<string, string>>;
    authHeadersSync: (extra?: Record<string, string>) => Record<string, string>;
    credentialsMode: () => RequestCredentials;
    jsonFetch: <T>(url: string, init?: RequestInit) => Promise<T>;
};

export declare function useKeyboardShortcuts(rootEl: Ref<HTMLElement | null>, handlers: ShortcutHandlers): void;

export declare function useLocale(localeRef: Ref<LocaleCode> | (() => LocaleCode)): {
    t: (key: string, vars?: Record<string, string | number>) => string;
    formatSize: (bytes: number | undefined | null) => string;
    formatDate: (ms: number | undefined | null, opts?: {
        time?: boolean;
    }) => string;
    formatDateFull: (ms: number | undefined | null) => string;
    formatMonthYear: (value: number | Date | undefined | null) => string;
    zonedYearMonth: (value: number | Date | undefined | null) => string;
    /**
     * zaman:z1 — the wire's `last_modified` as a `Date`, or null.
     *
     * Handed out because "seconds or milliseconds" is a fact about the WIRE,
     * not about formatting, and every caller that needs the instant itself
     * (rather than a string) was otherwise re-typing `v * (v < 1e12 ? 1000 :
     * 1)`. ListView had the third copy and used it to group rows by day — so
     * the grouping and the cell four pixels away were reading the same number
     * through two different converters.
     */
    toDate: typeof toDate;
    nodeDisplayName: (node: {
        basename: string;
    }) => string;
};

/**
 * Composable wrapper — components that want reactive "is Monaco ready
 * yet?" semantics can read the resolved promise. The implementation is
 * intentionally tiny: components don't need anything fancier than
 * `await ensureMonaco()` inside the click handler.
 */
export declare function useMonacoLoader(): {
    ensureMonaco: typeof ensureMonaco;
    ensureHighlight: typeof ensureHighlight;
    getMonaco: typeof getMonaco;
    getHighlight: typeof getHighlight;
};

export declare function useNFSExports(config: ExplorerConfig): {
    exports: ShallowRef<NFSExport[], NFSExport[]>;
    connection: Ref<    {
    enabled: boolean;
    host: string;
    port: number;
    } | null, NFSConnection | {
    enabled: boolean;
    host: string;
    port: number;
    } | null>;
    loading: Ref<boolean, boolean>;
    loaded: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    canMint: Ref<boolean | null, boolean | null>;
    revealed: Ref<    {
    export: {
    id: number;
    user_id: number;
    api_token_id?: number | null | undefined;
    label: string;
    storage_name?: string | undefined;
    prefix?: string | undefined;
    read_only: boolean;
    allow_cidrs?: string | undefined;
    created_at: string;
    last_used_at?: string | null | undefined;
    expires_at?: string | null | undefined;
    disabled_at?: string | null | undefined;
    };
    path: string;
    enabled: boolean;
    host: string;
    port: number;
    } | null, NFSExportCreated | {
    export: {
    id: number;
    user_id: number;
    api_token_id?: number | null | undefined;
    label: string;
    storage_name?: string | undefined;
    prefix?: string | undefined;
    read_only: boolean;
    allow_cidrs?: string | undefined;
    created_at: string;
    last_used_at?: string | null | undefined;
    expires_at?: string | null | undefined;
    disabled_at?: string | null | undefined;
    };
    path: string;
    enabled: boolean;
    host: string;
    port: number;
    } | null>;
    guideExport: ComputedRef<NFSExport | null>;
    load: () => Promise<void>;
    create: (req: {
        label: string;
        storage?: string;
        prefix?: string;
        read_only?: boolean;
        allow_cidrs?: string;
    }) => Promise<NFSExportCreated | null>;
    setDisabled: (id: number, disabled: boolean) => Promise<void>;
    remove: (id: number) => Promise<void>;
    dismissPath: () => void;
};

export declare function useOperations(): {
    active: Ref<    {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    queued: boolean;
    doneCount: number | null;
    totalCount: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    startedAt: number;
    settledAt: number | null;
    }[], Operation[] | {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    queued: boolean;
    doneCount: number | null;
    totalCount: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    startedAt: number;
    settledAt: number | null;
    }[]>;
    history: Ref<    {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    queued: boolean;
    doneCount: number | null;
    totalCount: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    startedAt: number;
    settledAt: number | null;
    }[], Operation[] | {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    queued: boolean;
    doneCount: number | null;
    totalCount: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    startedAt: number;
    settledAt: number | null;
    }[]>;
    runningCount: ComputedRef<number>;
    errorCount: ComputedRef<number>;
    hasError: ComputedRef<boolean>;
    overallPercent: ComputedRef<number | null>;
    sync: (group: string, items: Array<{
        input: OperationInput;
        actions?: OperationActions;
    }>) => void;
    cancel: (key: string) => void;
    retry: (key: string) => void;
    dismiss: (key: string) => void;
    clearHistory: () => void;
};

export declare function usePendingOps(config: ExplorerConfig, api: FileApi, opts?: UsePendingOpsOptions): {
    ops: Ref<    {
    id: number;
    op_type: "copy" | "move" | "delete";
    status: "pending" | "running" | "done" | "error";
    progress_total: number;
    progress_done: number;
    bytes_total?: number | undefined;
    bytes_done?: number | undefined;
    target_path: string | null;
    source_dir: string | null;
    source_count: number;
    error_message: string | null;
    started_at: string | null;
    finished_at: string | null;
    created_at: string | null;
    }[], PendingOp[] | {
    id: number;
    op_type: "copy" | "move" | "delete";
    status: "pending" | "running" | "done" | "error";
    progress_total: number;
    progress_done: number;
    bytes_total?: number | undefined;
    bytes_done?: number | undefined;
    target_path: string | null;
    source_dir: string | null;
    source_count: number;
    error_message: string | null;
    started_at: string | null;
    finished_at: string | null;
    created_at: string | null;
    }[]>;
    hasActive: ComputedRef<boolean>;
    register: (raw: PendingOp | Record<string, unknown>) => void;
    dismiss: (id: number) => void;
    poll: () => Promise<void>;
    startPolling: () => void;
    stopPolling: () => void;
};

export declare interface UsePendingOpsOptions {
    /** Called once an op flips into a terminal state (done|error). */
    onSettled?: (op: PendingOp) => void;
}

declare interface UserSearchResponse {
    users: UserSuggestion[];
}

declare interface UserSuggestion {
    id: number;
    email: string;
    display_name: string;
    role: string;
}

export declare function useS3Keys(config: ExplorerConfig): {
    keys: ShallowRef<S3AccessKey[], S3AccessKey[]>;
    connection: Ref<    {
    endpoint: string;
    enabled: boolean;
    path_style: boolean;
    } | null, S3Connection | {
    endpoint: string;
    enabled: boolean;
    path_style: boolean;
    } | null>;
    loading: Ref<boolean, boolean>;
    loaded: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    canMint: Ref<boolean | null, boolean | null>;
    revealed: Ref<    {
    key: {
    id: number;
    access_key_id: string;
    user_id: number;
    api_token_id?: number | null | undefined;
    label: string;
    bucket?: string | undefined;
    prefix?: string | undefined;
    created_at: string;
    last_used_at?: string | null | undefined;
    expires_at?: string | null | undefined;
    disabled_at?: string | null | undefined;
    };
    secret: string;
    endpoint: string;
    enabled: boolean;
    path_style: boolean;
    } | null, S3KeyCreated | {
    key: {
    id: number;
    access_key_id: string;
    user_id: number;
    api_token_id?: number | null | undefined;
    label: string;
    bucket?: string | undefined;
    prefix?: string | undefined;
    created_at: string;
    last_used_at?: string | null | undefined;
    expires_at?: string | null | undefined;
    disabled_at?: string | null | undefined;
    };
    secret: string;
    endpoint: string;
    enabled: boolean;
    path_style: boolean;
    } | null>;
    guideKey: ComputedRef<S3AccessKey | null>;
    load: () => Promise<void>;
    create: (req: S3KeyRequest) => Promise<S3KeyCreated | null>;
    setDisabled: (id: number, disabled: boolean) => Promise<void>;
    remove: (id: number) => Promise<void>;
    dismissSecret: () => void;
};

export declare function useSelection(items: () => FileNode[]): {
    selected: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
    anchor: Ref<string | null, string | null>;
    click: (path: string, mod?: {
        ctrl?: boolean;
        shift?: boolean;
    }) => void;
    clear: () => void;
    selectAll: () => void;
    has: (path: string) => boolean;
    add: (path: string) => void;
    remove: (path: string) => void;
    size: ComputedRef<number>;
    isEmpty: ComputedRef<boolean>;
    nodes: ComputedRef<FileNode[]>;
};

/** Reactive, override-aware view of the registry (registry order). */
export declare function useShortcutList(): ComputedRef<ShortcutView[]>;

export declare function useSSHKeys(config: ExplorerConfig): {
    keys: ShallowRef<SSHPublicKey[], SSHPublicKey[]>;
    connection: Ref<    {
    enabled: boolean;
    host: string;
    port: number;
    login: string;
    ftps?: {
    enabled: boolean;
    host: string;
    port: number;
    pasv_min: number;
    pasv_max: number;
    self_signed: boolean;
    } | undefined;
    } | null, SSHConnection | {
    enabled: boolean;
    host: string;
    port: number;
    login: string;
    ftps?: {
    enabled: boolean;
    host: string;
    port: number;
    pasv_min: number;
    pasv_max: number;
    self_signed: boolean;
    } | undefined;
    } | null>;
    loading: Ref<boolean, boolean>;
    loaded: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    canAdd: Ref<boolean | null, boolean | null>;
    hasUsableKey: ComputedRef<boolean>;
    load: () => Promise<void>;
    add: (key: string, name?: string) => Promise<boolean>;
    setDisabled: (id: number, disabled: boolean) => Promise<void>;
    remove: (id: number) => Promise<void>;
};

export declare function useTabs(opts: UseTabsOptions): {
    tabs: Ref<TabState[], TabState[]>;
    activeId: Ref<string, string>;
    activeTab: ComputedRef<TabState | null>;
    activeIndex: ComputedRef<number>;
    hasMultiple: ComputedRef<boolean>;
    restore: () => boolean;
    seed: (path: string, viewMode: ViewMode) => void;
    syncActive: (patch: Partial<Pick<TabState, "path" | "viewMode">>) => void;
    openTab: (path: string, o: {
        viewMode: ViewMode;
        background?: boolean;
        split?: TabSplit | null;
    }) => TabState;
    closeTab: (id: string) => TabState | null;
    activate: (id: string) => TabState | null;
    step: (delta: number) => TabState | null;
    move: (from: number, to: number) => void;
    setSplit: (split: TabSplit | null) => void;
};

declare interface UseTabsOptions {
    /** localStorage key; null disables persistence entirely. */
    storageKey: string | null;
}

/** Reactive handle for components: `{ themeMode, setThemeMode }`. */
export declare function useThemeModeState(): {
    themeMode: Ref<ThemeModePref>;
    setThemeMode: (mode: ThemeModePref) => void;
};

/** Reactive handle for components: `{ themeId, setTheme }`. */
export declare function useThemeState(): {
    themeId: Ref<string>;
    setTheme: (id: string) => void;
};

export declare function useTokens(config: ExplorerConfig): {
    tokens: ShallowRef<ApiToken[], ApiToken[]>;
    loading: Ref<boolean, boolean>;
    loaded: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    canMint: Ref<boolean | null, boolean | null>;
    revealed: Ref<    {
    token: string;
    row: {
    id: number;
    label: string;
    scopes: string;
    usernames?: string | null | undefined;
    created_at?: string | undefined;
    last_used_at?: string | null | undefined;
    expires_at?: string | null | undefined;
    };
    } | null, ApiTokenCreated | {
    token: string;
    row: {
    id: number;
    label: string;
    scopes: string;
    usernames?: string | null | undefined;
    created_at?: string | undefined;
    last_used_at?: string | null | undefined;
    expires_at?: string | null | undefined;
    };
    } | null>;
    load: () => Promise<void>;
    create: (req: ApiTokenRequest) => Promise<ApiTokenCreated | null>;
    remove: (id: number) => Promise<void>;
    dismiss: () => void;
};

export declare function useUploadChunked(config: ExplorerConfig, api: FileApi, storage?: ResumeStorage | null): {
    uploadFile: (opts: UploadOptions) => Promise<UploadResult>;
    /** True when this file is big enough (and the endpoints exist) to chunk. */
    shouldChunk: (file: {
        size: number;
    }) => boolean;
    /** The size at which chunking kicks in. */
    threshold: () => number;
    resumableFor: (path: string, file: File) => ResumeRecord | null;
    listResumable: () => ResumeRecord[];
    discardResumable: (rec: ResumeRecord) => Promise<void>;
};

/**
 * Check `password` against a folder marker. Resolves to the derived KEK on
 * success, or `null` on a wrong password (GCM tag mismatch on the verify
 * blob). Never talks to any server.
 *
 * ⚠ This returns the KEK, not the FMK. On a v1 folder they are the same key;
 * on a v2 `fmk: 'wrapped'` folder they are not. Use `unlockWithPassword` to
 * get the key that actually decrypts files.
 */
export declare function verifyPassword(marker: E2eMarker, password: string): Promise<CryptoKey | null>;

/** Tier `viewer`, as stored in this browser. `''` = no choice. Reactive. */
export declare function viewerTimeZone(): string;

export declare type ViewMode = 'list' | 'grid' | 'gallery';

declare type ViewMode_2 = 'list' | 'grid' | 'gallery';

/** One feature's corner of the document. */
export declare interface ViewPrefsSlot<T> {
    /** What is stored, or undefined — including before the document lands. */
    get(): T | undefined;
    /** Replace it. A no-op when there is nobody to save for. */
    set(value: T): void;
    /** Remove the key entirely. */
    clear(): void;
    /** Has the document been read yet? Reactive — read it in a `computed`. */
    ready(): boolean;
    /** Is there an account behind this session at all? Reactive. */
    persistable(): boolean;
}

/**
 * Claim `namespace` as a top-level key in the per-user view-prefs document.
 *
 * ⚠ The three names this module owns are refused outright rather than
 * quietly renamed: a slot called `c` that silently became `c2` would be a
 * value the caller could never read back.
 */
export declare function viewPrefsSlot<T>(namespace: string): ViewPrefsSlot<T>;

/**
 * THE TRANSPORT — injected, so this module knows nothing about fetch, auth or
 * URLs and a test can drive it with two functions.
 *
 * `load` resolves the stored document, or null when there is nobody to store
 * one for (an embed on a shared app token, a public share link). `save` is
 * FIRE AND FORGET on purpose: a view preference is never worth blocking an
 * interface for, and a failed write must leave the change on screen — the next
 * write sends the whole document anyway, so a dropped one heals itself.
 */
export declare interface ViewPrefsTransport {
    load: () => Promise<unknown>;
    save: (doc: unknown) => void;
}

/** What is on screen, in the order it is drawn — the list a Select-all or a
 *  Shift-range has to be arithmetic over. */
declare function visibleNodes(): FileNode[];

/**
 * HAS ANYBODY EVER SIZED THIS TABLE — the one bit that separates "I have never
 * touched this" from "I deliberately made Name narrow".
 *
 * ⚠⚠ Without it the two are indistinguishable and the first resize is undone
 * by the next pane resize: an untouched table is sized to the pane it is in
 * (`tableLayout`), so a person who drags Name to 140 and then opens the
 * inspector gets Name recomputed back to whatever the narrower pane suggests.
 * The stored widths are that bit — the moment they exist, the pane stops
 * having an opinion.
 *
 * ⚠⚠ The bit is NAME's width, not "the map is empty", and that is a migration
 * decision rather than a stylistic one. Name was not a column until this
 * change, so every document written before it — including the owner's, which
 * carries `{size: 89, type: 125}` from the layout he rejected — has widths but
 * has never been asked about Name. Reading those as "configured" would open
 * his table at Name's shipped 260px, wider than his pane, scrolled sideways on
 * first sight, at a width nobody ever chose. Reading them as "Name is still
 * auto" keeps the two numbers he did choose and derives the one he did not.
 * The first drag writes every width at once (`freezeWidths`), so a table
 * somebody has actually sized can never fall back into this branch.
 */
export declare function widthsAreAuto(): boolean;

/**
 * Which calendar day an instant falls on, in `zone`, as a day count since the
 * epoch. Comparable and subtractable — `a - b === 1` means "the day before".
 *
 * Why not `new Date(ms).getDate()`: that is the DEVICE's calendar, and the
 * date a listing groups by has to be the same date it prints in the cell four
 * pixels away. A file touched at 01:00 in Istanbul belongs under "Yesterday"
 * for a viewer reading UTC and under "Today" for one reading Istanbul.
 *
 * `en-CA` is not a locale choice, it is the shortest route to ISO `Y-M-D` out
 * of `Intl`; the parts are re-assembled through `Date.UTC` so the arithmetic
 * happens on a calendar with no offsets in it at all.
 */
export declare function zonedDayNumber(d: Date, zone?: string): number;

export { }