import { AllowedComponentProps } from 'vue';
import { Attrs } from 'vue';
import { Component } 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 { ExtractPropTypes } from 'vue';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { InjectionKey } from 'vue';
import { LicenseInfo } from '@brftech/filex-app-ui/protocol';
import { nextTick } from 'vue';
import { OnCleanup } from '@vue/reactivity';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { ShallowRef } from 'vue';
import { Slot } from 'vue';
import { ToastParams } from '@brftech/filex-app-ui/protocol';
import { VNode } 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>;
openAppTarget: typeof openAppTarget;
revealNotification: typeof revealNotification;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (err: {
message: string;
context?: unknown;
}) => any;
refresh: () => any;
"share-created": (payload: {
path: string;
url: string;
pin: string | null;
}) => any;
"open-my-shares": () => any;
"open-app-store": () => 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;
"open-app-home": (p: {
plugin: string;
view: string;
}) => 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;
"onOpen-my-shares"?: (() => any) | undefined;
"onOpen-app-store"?: (() => 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;
"onOpen-app-home"?: ((p: {
plugin: string;
view: string;
}) => 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 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_2) => 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_2) => 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;
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_2) => 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_2) => 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;
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_2) => 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 trash?: boolean | undefined;
readonly clipped?: Set<string> | undefined;
readonly extraFilters?: (DriveFilters | null) | undefined;
readonly extraFiltersOnServer?: boolean | undefined;
readonly canWrite?: boolean | undefined;
readonly canPaste?: boolean | undefined;
readonly selected: Set<string>;
readonly filters: DriveFilters;
readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
readonly folderPreviews?: boolean | undefined;
readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
readonly starredIds?: Set<number> | undefined;
readonly starOverrides?: Map<number, boolean> | 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;
trash?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
extraFiltersOnServer?: boolean;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
folderPreviews?: boolean;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starOverrides?: Map<number, boolean>;
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;
e2eRoot: () => 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;
trash?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
extraFiltersOnServer?: boolean;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
folderPreviews?: boolean;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starOverrides?: Map<number, boolean>;
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" | "rowCount" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowPaths" | "e2eRoot" | ("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;
e2eRoot: () => 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 trash?: boolean | undefined;
readonly clipped?: Set<string> | undefined;
readonly extraFilters?: (DriveFilters | null) | undefined;
readonly extraFiltersOnServer?: boolean | undefined;
readonly canWrite?: boolean | undefined;
readonly canPaste?: boolean | undefined;
readonly selected: Set<string>;
readonly filters: DriveFilters;
readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
readonly folderPreviews?: boolean | undefined;
readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
readonly starredIds?: Set<number> | undefined;
readonly starOverrides?: Map<number, boolean> | 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;
trash?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
extraFiltersOnServer?: boolean;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
folderPreviews?: boolean;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starOverrides?: Map<number, boolean>;
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;
e2eRoot: () => 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;
trash?: boolean;
clipped?: Set<string>;
extraFilters?: DriveFilters | null;
extraFiltersOnServer?: boolean;
canWrite?: boolean;
canPaste?: boolean;
selected: Set<string>;
filters: DriveFilters;
thumbSrc?: (n: FileNode) => string | null;
folderPreviews?: boolean;
keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
starredIds?: Set<number>;
starOverrides?: Map<number, boolean>;
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" | "rowCount" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowPaths" | "e2eRoot" | ("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;
e2eRoot: () => 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_21, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
retry: () => any;
pin: (pin: string) => any;
"update:locale": (v: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_21> & Readonly<{
onRetry?: (() => any) | undefined;
onPin?: ((pin: string) => any) | undefined;
"onUpdate:locale"?: ((v: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_3: DefineComponent<__VLS_Props_42, {
reload: typeof reload;
goUp: typeof goUp;
getPath: typeof getPath;
visibleNodes: typeof visibleNodes;
loadFolder: typeof loadFolder;
rowCount: typeof rowCount;
rowPaths: typeof rowPaths;
dirPerm: typeof dirPerm;
e2eRoot: typeof e2eRoot;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
[x: string]: any;
}, string, PublicProps, Readonly<__VLS_Props_42> & 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 const __VLS_component_4: DefineComponent<__VLS_Props_54, {
store: ComputedRef<ColumnStore<string>>;
layout: ComputedRef<GenericTableLayout<string>>;
pinLead: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
sort: (payload: {
key: string;
dir: "asc" | "desc";
}) => any;
page: (page: number) => any;
"row-click": (row: any, ev: MouseEvent) => any;
"row-dblclick": (row: any, ev: MouseEvent) => any;
"row-contextmenu": (row: any, ev: MouseEvent) => any;
"check-click": (row: any, ev: MouseEvent) => any;
"row-action": (key: string, row: any, action: ContextAction) => any;
"row-dragstart": (row: any, ev: DragEvent) => any;
"row-dragover": (row: any, ev: DragEvent) => any;
"row-dragleave": (row: any, ev: DragEvent) => any;
"row-drop": (row: any, ev: DragEvent) => any;
"row-touchstart": (row: any, ev: TouchEvent) => any;
"row-touchend": (ev: TouchEvent) => any;
"row-touchmove": (ev: TouchEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_54> & Readonly<{
onSort?: ((payload: {
key: string;
dir: "asc" | "desc";
}) => any) | undefined;
onPage?: ((page: number) => any) | undefined;
"onRow-click"?: ((row: any, ev: MouseEvent) => any) | undefined;
"onRow-dblclick"?: ((row: any, ev: MouseEvent) => any) | undefined;
"onRow-contextmenu"?: ((row: any, ev: MouseEvent) => any) | undefined;
"onCheck-click"?: ((row: any, ev: MouseEvent) => any) | undefined;
"onRow-action"?: ((key: string, row: any, action: ContextAction) => any) | undefined;
"onRow-dragstart"?: ((row: any, ev: DragEvent) => any) | undefined;
"onRow-dragover"?: ((row: any, ev: DragEvent) => any) | undefined;
"onRow-dragleave"?: ((row: any, ev: DragEvent) => any) | undefined;
"onRow-drop"?: ((row: any, ev: DragEvent) => any) | undefined;
"onRow-touchstart"?: ((row: any, ev: TouchEvent) => any) | undefined;
"onRow-touchend"?: ((ev: TouchEvent) => any) | undefined;
"onRow-touchmove"?: ((ev: TouchEvent) => any) | undefined;
}>, {
total: number;
sort: {
key: string;
dir: "asc" | "desc";
} | null;
theme: ThemeMode;
locale: LocaleCode;
page: number;
groups: Group[];
empty: string | null;
ariaLabel: string;
rowKey: string | ((row: any) => string | number);
tableId: string;
columnStore: ColumnStore;
candidates: string[];
metrics: LayoutMetrics;
isSelected: (row: any) => boolean;
sortClosed: string | null;
rowClass: (row: any, index: number) => string | Record<string, boolean> | undefined;
rowAttrs: (row: any) => Record<string, unknown>;
rowActions: (row: any) => ContextAction[];
rowActionsTestId: (row: any) => string | undefined;
actionsWidth: number;
framed: boolean;
pageSize: number;
pages: number;
footNote: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
listEl: HTMLDivElement;
colMenuEl: HTMLDivElement;
}, any>;

declare type __VLS_Props = {
    config: ExplorerConfig;
};

declare type __VLS_Props_10 = {
    /** The unread count as the server last reported it. */
    count: number | null | undefined;
};

declare type __VLS_Props_11 = {
    /** The rows, in order. */
    actions: AccountAction[];
    /** Who is signed in — a name, an address and a picture, any of them absent. */
    user?: AccountPerson | null;
    /** Which filex this is — the server's own answer (capabilities). */
    version?: string | null;
    /** The active language — any offered one, a language pack's included. */
    locale: string;
    /** Accessible name when this account has neither a name nor an address. */
    fallbackLabel: string;
};

declare type __VLS_Props_12 = {
    modelValue: boolean;
    /** Everything this dialog cannot know by itself (lib/userSettingsHost). */
    host: UserSettingsHost;
    /** The pane to open on (the admin Notifications page opens `notifications`). */
    initialSection?: 'profile' | 'preferences' | 'notifications' | 'security' | 'ai';
};

declare type __VLS_Props_13 = {
    /** The entries, already limited to what the reader may open. */
    entries: MegaMenuEntry[];
    /** The navigation's accessible name. */
    label: string;
    mode?: 'bar' | 'list';
};

declare type __VLS_Props_14 = {
    locale: string;
    /** A phone: a button and a layer over the window, instead of the box. */
    compact?: boolean;
    /** What the host can find by itself (pages, settings), already limited to what the reader may open. */
    items: PanelSearchItem[];
    /** The server's hits for a query (people, keys, apps…), already limited by the reader's role. */
    remote?: (query: PanelSearchQuery) => Promise<PanelSearchItem[]>;
    /** File hits for words, at most `limit`. */
    files?: (text: string, limit: number) => Promise<PanelSearchItem[]>;
    /** Where the recent searches live. */
    recent?: PanelRecentStore;
    /** The palette key opens this search (only one search on a page should say yes). */
    shortcut?: boolean;
};

declare type __VLS_Props_15 = {
    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;
    /**
     * The explorer's language. ⚠ This tray printed English whatever the
     * explorer spoke ("Recently opened", "5m ago") — strings no language pack
     * could reach. Absent = English.
     */
    locale?: string;
};

declare type __VLS_Props_16 = {
    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;
    /** Could this person set a missing service up (`capabilities.caller_admin`)?
     *  Adds WHERE to the line that says which families are missing. */
    canConfigure?: boolean;
    /** Make a DRAFT rather than the file (issue #71): the server keeps drafts
     *  for this person (`capabilities.drafts`). Absent: the file is created. */
    drafts?: boolean;
};

declare type __VLS_Props_17 = {
    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. `save` is an app's
     * save-as (`file.saveAs`, AppFrame): "Save here".
     */
    mode?: 'move' | 'copy' | 'choose' | 'save';
    /**
     * The dialog's title, when the caller has a better one than the mode's —
     * an app's save-as names the app and the file (security review UI-14:
     * what filex draws for an app says who is asking).
     */
    title?: string;
    /** The explorer's theme, for a dialog drawn outside its root. */
    theme?: 'light' | 'dark' | 'auto';
    /**
     * What the answer is. `dir` (the default) is the folder you are standing in;
     * `file` lists the files too and the answer is the one you tick — an app
     * plugin's `file-chooser` asks for this. A file pick has no write check:
     * the chooser reads, it never writes.
     */
    pick?: 'dir' | 'file';
    /** The parent is running the operation: the dialog stays up but inert. */
    busy?: boolean;
    /**
     * wiring:e2 vault — the vault folders the explorer knows (opened here, or
     * remembered). The listings add the ones the server names
     * (`e2e_vault`, `e2e_vault_root`); `api` lists an open vault from its index.
     */
    vaultRoots?: string[];
    /** wiring:e2 vault — the vault the items are in; null or absent: outside
     *  every vault. Inside a vault only that vault is a destination; outside,
     *  no vault is (docs/E2E-VAULT-FORMAT.md: that is an upload or a download). */
    vaultFrom?: string | null;
};

declare type __VLS_Props_18 = {
    options: ChoiceOption[];
    /** A string (single) or a list of strings (several). */
    modelValue: string | string[] | null | undefined;
    multi?: boolean;
    disabled?: boolean;
    invalid?: boolean;
    /** One strip with the chosen cell filled: two to four short answers inline. */
    segmented?: boolean;
    /** Segmented, and each cell shows only its icon (the label names it). */
    iconOnly?: boolean;
    /** Ties the group to its own label for a screen reader. */
    ariaLabelledby?: string;
    ariaLabel?: string;
    /** `surface-choice` → `data-testid="surface-choice-<value>"`. */
    testidPrefix?: string;
    /** The group's own `data-testid` (`choice-buttons` when not given). */
    testid?: string;
};

declare type __VLS_Props_19 = {
    modelValue?: Value | null;
    options: SelectOption[];
    id?: string;
    name?: string;
    /** Shown in the field while no option is chosen. */
    placeholder?: string;
    required?: boolean;
    disabled?: boolean;
    invalid?: boolean;
    /** The field's height: the `--fe-h-sm|md|lg` control heights. */
    size?: 'sm' | 'md' | 'lg';
    ariaLabel?: string;
    ariaLabelledby?: string;
    ariaDescribedby?: string;
    /** The message a form's own validation carries when a required value is missing. */
    requiredMessage?: string;
    /** `data-testid` of the combobox; the list is `<testid>-list`, an option `<testid>-option-<value>`. */
    testid?: string;
};

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;
    /**
     * Could this person set up a missing service (`capabilities.caller_admin`)?
     * Only changes WHICH sentence a missing document server gets: an
     * administrator is told where to set it up, everybody else that it is not
     * available here and how to get the file anyway.
     */
    canConfigure?: boolean;
    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;
    /**
     * Open `file` AS this type — an extension, no dot — instead of by its name
     * (#56). The New document dialog made `LICENSE` as Plain text, so it opens
     * in the text editor although its name picks no viewer at all; `README`
     * made as Markdown opens in the markdown editor. Unset: the name decides,
     * as it always has. The host passes it for the one file it applies to.
     */
    openAs?: string | null;
    /**
     * Drafts (issue #71): the drafts API, `<api>/api/files/drafts`. With it, a
     * file whose path is a draft's (`<storage>://.filex-drafts/…`, lib/
     * internalPaths `draftKeyOf`) is edited AS a draft: the bar across the top
     * says where it will be saved and carries the Save that puts it there,
     * closing asks what should become of it (DraftCloseModal), and leaving the
     * page with edits in it asks the browser's own question. Every host passes
     * it — the explorer, the standalone editor tab, the desktop's document
     * windows (which load that tab) — so a draft behaves the same wherever it
     * is opened. Absent: nothing here changes.
     */
    draftsEndpoint?: string | null;
    /**
     * v4 — an app's own interface that opens this file (a `viewer` view the
     * host matched to it, docs/APP-PLUGINS-API.md → An app's own interface).
     * It takes the built-in viewer's place: the same bar, the same draft
     * behaviour, the same close question. Needs `api`.
     */
    appViewer?: PluginViewRow | null;
    /**
     * 0.51 - the host opens this file in ONLYOFFICE although its extension picks
     * another viewer: a .csv, whose handler (lib/appViewer) is ONLYOFFICE by
     * default while it is configured, or "Open with" chose it. The office editor
     * takes the built-in viewer's place, with an office document's Edit button.
     */
    inOffice?: boolean;
    /** The explorer's API — what an app's interface reads and saves through. */
    api?: FileApi | null;
    /** The person's display name, for an app's interface. */
    userName?: string;
    /** Storage names an app's save-as may span (AppFrame `storages`); absent,
     *  the frame asks the server's listing. */
    storages?: string[];
    /**
     * #184 - the document open in the office editor changed OUTSIDE it. The
     * host says so (the desktop app watches the file on the computer, the web
     * hears the server's realtime feed); the viewer decides: nothing of this
     * editor's unsaved, the new version is loaded with a note; otherwise the
     * person is asked which version stays (OutsideChangeModal), and the answer
     * goes back as `outside-resolved`. lib/outsideChange has the rule.
     */
    outsideChange?: OutsideChange | null;
};

declare type __VLS_Props_20 = {
    /**
     * `share` → `/s/<token>`; `request` → `/d/<token>`.
     *
     * ⚠ `/p/<token>` is RETIRED (v3 §1: an app's public page is a share now)
     * and the server 301s it to the share, so there is no third kind here and
     * no second code path for the transition.
     */
    kind: 'share' | 'request';
    /** From the route. Empty (a URL that is not a token) draws "not available". */
    token?: string;
    /**
     * API origin; empty = same origin. Unset: the base path this document was
     * served under (lib/appBase) — `/filex` for the admin app under a sub-path,
     * `''` everywhere else.
     */
    base?: string;
    /** Forced by the host; otherwise the device's choice, then the browser's. */
    locale?: LocaleCode | string;
    /** Forced by the host; otherwise the instance's default, then the device's. */
    theme?: ThemeMode;
};

declare type __VLS_Props_21 = {
    status: PublicStatus;
    locale: LocaleCode | string;
    /** `light` | `dark` — already resolved; `auto` is the caller's to answer. */
    theme?: 'light' | 'dark' | ThemeMode;
    /** The instance's name (branding, or the product's own). */
    brandName: string;
    logoUrl?: string;
    /** `--fe-*` overrides from the instance's accent colour. */
    accentStyle?: Record<string, string>;
    footerText?: string;
    hidePoweredBy?: boolean;
    /**
     * How much room the body needs (`lib/publicLayout`). Every state that is
     * NOT `ready` overrides it to `gate`: a PIN box, "this link is not
     * available" and "thank you" are the same short, centred card whatever
     * was going to be behind them.
     */
    layout?: PublicLayout;
    /**
     * The round badge a READY body opens with — `file` or `folder`. Every
     * other badge is a state of the shell's own (a padlock, a tick, a warning
     * sign, a spinner) and is not the caller's to pick.
     */
    badge?: 'file' | 'folder' | '';
    /** The heading: a file name, a folder, a plugin page's title. */
    title?: string;
    /** The line under it — a share message, a signature request's subject. */
    subject?: string;
    /** RFC 3339, or null for "does not expire". */
    expiresAt?: string | null;
    /** Visits left before the link stops answering; null = uncounted. */
    visitsLeft?: number | null;
    /**
     * The longest PIN the server lets any link carry (`pin_max`, the one PIN
     * rule in internal/share). The PIN box stops there; absent = no cap of the
     * box's own.
     */
    pinMax?: number | null;
    pinBusy?: boolean;
    pinFailure?: '' | 'wrong' | 'locked';
    lockMessage?: string;
    /** A failure outside the conversation, in the server's words. */
    failure?: string;
    /**
     * Drawn INSIDE another page that has a main region of its own - the
     * admin's Corporate identity preview (PublicLinkPreview), or an embedder's
     * page. The card is then a plain block, not a `<main>`: a document has one
     * main landmark, and a `<main>` inside another is not valid HTML (the
     * panel's page and the preview's card were two of them, e2e 204). The link
     * page itself, which IS the whole page, keeps its `<main>`.
     */
    embedded?: boolean;
};

declare type __VLS_Props_22 = {
    brandName?: string;
    logoUrl?: string;
    /** A hex colour, as the operator typed it; anything else means "none". */
    accent?: string;
    footerText?: string;
    hidePoweredBy?: boolean;
    locale: LocaleCode | string;
    theme?: 'light' | 'dark';
    /** The file the sample link shares. */
    sample?: {
        name: string;
        size: number;
        mime?: string;
    };
};

declare type __VLS_Props_23 = {
    locale: LocaleCode | string;
    busy?: boolean;
    /** `wrong` | `locked` | '' — from the composable, not from a status code here. */
    failure?: '' | 'wrong' | 'locked';
    /** The server's own words for a lock, when it sends any. */
    lockMessage?: string;
    /**
     * The longest PIN any link may carry, as the SERVER says it (`pin_max`,
     * internal/share CheckPINLength). ⚠ Not a number of this box's own: it
     * used to stop at a hard-coded 12 while the server took a PIN of any length
     * through the API, so such a link could not be opened from this page.
     * Absent = the box does not cut what is typed; the server answers.
     */
    maxLength?: number;
};

declare type __VLS_Props_24 = {
    link: PublicLinkStore<PublicShareInfo> & {
        downloadUrl: (o?: {
            zip?: boolean;
            path?: string;
        }) => string;
        noJsUrl: () => string;
    };
    locale: LocaleCode | string;
    theme?: ThemeMode;
};

declare type __VLS_Props_25 = {
    info: PublicRequestInfo | null;
    uploads: Array<{
        name: string;
        size: number;
        percent: number;
        state: string;
        error?: string;
    }>;
    locale: LocaleCode | string;
    disabled?: boolean;
    /**
     * Leave the folder's name out of the body. The public page's heading is
     * already that name (`PublicLinkPage` titles a request by its folder), and
     * printing it again under itself read as a stutter.
     */
    hideFolder?: boolean;
};

declare type __VLS_Props_26 = {
    modelValue: string;
    /** Shown beside a language an app added ("from <app>"). */
    pluginNote?: (plugin: string) => string;
};

declare type __VLS_Props_27 = {
    nodes: SurfaceNode[];
    locale: LocaleCode;
    theme?: ThemeMode;
    /** Field-level errors the surface carries, keyed by node id / field key. */
    errors?: Record<string, PluginText>;
    /** The surface's values (node id → value; form fields flat). */
    values?: Record<string, unknown>;
    /** Absent in a bare render: choosers and previews say so instead of failing. */
    api?: SurfaceApi;
    /** The plugin the surface belongs to (the people-picker's lookup asks for it). */
    plugin?: string;
    /** Storage names a file-chooser may span; where its picker opens. */
    storages?: string[];
    startAt?: string;
    /** The host is talking to the server: inputs and buttons stay put. */
    disabled?: boolean;
    /** A public page's exposed copies (`pub:N`) → a URL the browser may load (M3). */
    fileUrl?: FileRefResolver;
    /** Where pdf.js fetches its worker from; the pinned CDN copy when absent. */
    pdfWorkerUrl?: string | null;
    /**
     * v3 §2.1 — field keys a refused submit is waiting for. Passed down to the
     * form so the star and the "required" line land on the FIELD, not in a
     * banner the person has to map back onto a box themselves.
     */
    invalidKeys?: string[];
    /**
     * v3 §3.2 — `page` means this surface owns the viewport, so a `pdf-fields`
     * node fits the document to the screen instead of to the text column. The
     * frame says which; a node never measures the window itself.
     */
    layout?: 'inline' | 'page';
    /** The box a `page` layout's document may fill (a CSS length). */
    pageHeight?: string;
};

declare type __VLS_Props_28 = {
    /** The conversation this body belongs to (`usePluginSurface`). */
    conv: PluginSurfaceStore;
    locale: LocaleCode;
    theme?: ThemeMode;
    /** Absent in a bare render (the public page has no explorer API). */
    api?: SurfaceApi;
    /** The plugin the surface belongs to — the people-picker's lookup asks for it. */
    plugin?: string;
    storages?: string[];
    startAt?: string;
    /** A public page's exposed copies (`pub:N`) → a URL the browser may load. */
    fileUrl?: FileRefResolver;
    /** The last toast the frame collected, if it shows one inline. */
    toast?: string;
    /**
     * v3 §3.2 — `page` lets a `pdf-fields` node take the viewport instead of
     * sitting in the document flow. The FRAME knows which it is; the nodes do
     * not, and must not guess from the window size (an embed in a narrow
     * column is not a page).
     */
    layout?: 'inline' | 'page';
    /** Where the document may grow to in `page` layout — the frame's own box. */
    pageHeight?: string;
};

declare type __VLS_Props_29 = {
    conv: PluginSurfaceStore;
    locale: LocaleCode;
    /** `plugin-view` → `data-testid="plugin-view-action-<id>"`. */
    testidPrefix: string;
    /** The inspector's row is compact; every other frame uses the full size. */
    small?: boolean;
};

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_30 = {
    locale: LocaleCode;
    theme?: ThemeMode;
    api: FileApi;
    plugin: string;
    view: string;
    /** Adapter-qualified path the page was opened on; echoed on every event. */
    path?: string;
    /** Storage names a file-chooser may span; where its picker opens. */
    storages?: string[];
    startAt?: string;
    /** Where "back to the files" goes. Absent: the button is not drawn. */
    backHref?: string;
    /** Where the operations tray lives, for the queued state. */
    opsHref?: string;
    /**
     * The prefix the SPA is served from (`/admin/`, `/drive/`) — what a
     * `Surface.open` address is built against (v3 §3.0). Absent: the request
     * is dropped, because a wrong address is worse than none.
     */
    mountBase?: string;
    /**
     * The CHROME around the conversation; the conversation itself is the same
     * either way.
     *
     * `page` (the default) is a browser tab of its own: a title bar, one column
     * at reading width, the viewport's height, a footer stuck to its bottom.
     * `embedded` is the same screen drawn INSIDE a host's page — the admin
     * panel's Apps section, an embed that already has a header — and brings
     * none of those three, because the host has already said where the screen
     * begins, how wide it is and what it is called.
     *
     * ⚠ A step carrying a document keeps the INLINE layout when embedded. The
     * `page` rule fits a PDF to the VIEWPORT (v3 §3.2); inside a host's page
     * the viewport is not this frame's box, so the same rule would fit the
     * document to a height the frame does not have.
     */
    frame?: 'page' | 'embedded';
    /**
     * The section of a home page to open (`surface.sections`), as the host's
     * address says. ⚠ The HOST owns it: choosing a section emits `section`
     * and the host puts it in its URL, which comes back here — so Back walks
     * the sections, and a link names one.
     */
    section?: string;
};

declare type __VLS_Props_31 = {
    id: string;
    modes?: unknown;
    width?: unknown;
    height?: unknown;
    modelValue: SignatureValue | null | undefined;
    locale: LocaleCode;
    disabled?: boolean;
    invalid?: boolean;
    /** The face a typed signature starts in (a `lib/signFonts` key). */
    font?: unknown;
    /**
     * The faces a typed signature may use; one face means no picker at all.
     * A box whose face the REQUESTER chose passes just that one, so what the
     * signer sees is what the stamper prints.
     */
    fonts?: unknown;
    /**
     * The box's name, drawn as a field label — with the same `*` a required
     * form field carries (v3). ⚠ The owner, 2026-09-21: "imza zorunluydu ama
     * imzanın zorunlu olduğunu `*` ile belirtmiyoruz". The signature was the
     * one required box on the screen that did not say so, because it was a
     * plain text line above the pad rather than a label.
     */
    label?: string;
    required?: boolean;
};

declare type __VLS_Props_32 = {
    id: string;
    src?: PdfFieldsSource;
    mode?: string;
    fields?: unknown;
    signers?: unknown;
    signer?: string;
    types?: unknown;
    /** `define` / `edit`: the date layouts a `date` box may be written in. */
    formats?: unknown;
    /** The date control's three captions, as the plugin words them (`date_labels`). */
    dateLabels?: unknown;
    /** Edit: the `fields[]` the host holds; fill: `{fields: [{id, value}]}`. */
    modelValue?: unknown;
    locale: LocaleCode;
    theme?: ThemeMode;
    disabled?: boolean;
    invalid?: boolean;
    api?: Pick<FileApi, 'fetchBlob'>;
    fileUrl?: FileRefResolver;
    pdfWorkerUrl?: string | null;
    /**
     * v3 §3.2 — `page`: this node owns the screen, so the document is fitted
     * to the BOX rather than to the text column, and the person never scrolls
     * in two directions to reach a signature box. The zoom controls stay:
     * fitting is the starting point, not a cage.
     */
    layout?: 'inline' | 'page';
    /** The height a `page` layout may fill (a CSS length). Default: the frame's. */
    pageHeight?: string;
    /**
     * The lines the plugin can print under a signature, offered per signature
     * box on the author's screens (`lib/pdfFields.PdfStampLine`).
     */
    stampLines?: unknown;
};

declare type __VLS_Props_33 = {
    /** The reader's language. Defaults to English, as every core surface does. */
    locale?: LocaleCode | string;
};

declare type __VLS_Props_34 = {
    /** The server's release (`capabilities.release`, `v0.54.0`). Unknown →
     *  nothing drawn. */
    version?: string | null;
};

declare type __VLS_Props_35 = {
    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_36 = {
    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 type __VLS_Props_37 = {
    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_38 = {
    open: boolean;
    locale: LocaleCode;
    theme?: 'light' | 'dark' | 'auto';
};

declare type __VLS_Props_39 = {
    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_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_40 = {
    center: OperationsStore;
    locale: LocaleCode;
    narrow?: boolean;
};

declare type __VLS_Props_41 = {
    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_42 = {
    /** 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;
    /** These rows are the Trash (ListView `trash`: deleted-on, deleted-from, time left). */
    trash?: 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;
    /** The server already applied `extraFilters` to these rows (a search it
     *  ran with the narrowing as parameters, task #207): the pane counts them
     *  as on - the empty state, "Clear" - but does not narrow again. */
    extraFiltersOnServer?: boolean;
    canWrite?: boolean;
    canPaste?: boolean;
    selected: Set<string>;
    filters: DriveFilters;
    thumbSrc?: (n: FileNode) => string | null;
    /** Folder previews are on (capabilities `folder_previews`): the peek on
     *  a resting pointer. Absent: on. The cards follow the listing, which
     *  sends no `preview` while they are off. */
    folderPreviews?: boolean;
    keepBadgeFor?: (n: FileNode) => 'kept' | 'syncing' | 'cloud' | 'partial' | null;
    starredIds?: Set<number>;
    /** Stars the person just toggled (id -> starred), until the next answer
     *  says it itself. The pane's own rows carry `starred` (task #207). */
    starOverrides?: Map<number, boolean>;
    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_43 = {
    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;
    /** Encrypt this existing folder in place (its name as people read it). */
    existing?: string | null;
    /** wiring:e2 vault — the server has the vault (`capabilities.e2e_vault`).
     *  Offered for a NEW folder only: an existing one is never converted. */
    vaultAvailable?: boolean;
};

declare type __VLS_Props_44 = {
    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;
     *  'replaced' = a re-key issued a new one and the old one stopped working;
     *  'file' = a single encrypted file (.fxe) was just made (wiring:e2 fxe). */
    variant?: 'created' | 'upgraded' | 'replaced' | 'file';
};

declare type __VLS_Props_45 = {
    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_46 = {
    config: ExplorerConfig;
    /** 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_47 = {
    /** The driver id; absent draws no driver tag (the explorer's read-only mark). */
    driver?: string;
    readOnly?: boolean;
    /** `false` draws "Disabled"; `undefined` / `true` draws nothing. */
    enabled?: boolean;
    locale?: LocaleCode | string;
};

declare type __VLS_Props_48 = {
    fields: StorageField[];
    modelValue: Record<string, unknown>;
    locale: LocaleCode;
    /** Keys to mark as failing validation (missing required). */
    invalid?: string[];
    /**
     * Field-level messages, keyed by field key — what a server (an app
     * plugin's `surface.errors`, a driver's 400) said about the value. A key
     * here is invalid too, and its own words replace the generic "required".
     */
    errors?: Record<string, string>;
    disabled?: boolean;
};

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

declare type __VLS_Props_5 = {
    kind: TagKind;
    /** Edge length in px. */
    size?: number;
};

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

declare type __VLS_Props_51 = {
    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_52 = {
    config: ExplorerConfig;
    /** Storage names the caller may see, for the confinement picker. */
    storages: string[];
};

declare type __VLS_Props_53 = {
    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_54 = {
    rows: any[];
    columns: DataColumn[];
    /** How a row is keyed: a property name or a function. Default: its index. */
    rowKey?: string | ((row: any) => string | number);
    /** The name its arrangement is remembered under (`lib/tablePrefs`).
     *  Every table in the product passes one; the guard test refuses a table
     *  without. Absent = remembered for this mount only. */
    tableId?: string;
    /** The explorer passes its own per-folder store; everybody else gets one
     *  built from `tableId`. */
    columnStore?: ColumnStore;
    /** Which non-lead columns this listing will draw at all (the explorer's
     *  Location only in cross-folder views). Default: every column. */
    candidates?: string[];
    /** Table arithmetic, for a caller whose tracks differ (the explorer). */
    metrics?: LayoutMetrics;
    locale?: LocaleCode;
    theme?: ThemeMode;
    loading?: boolean;
    /** What an empty table says. '' or null says nothing: no empty-state box
     *  is drawn at all (a caller showing an error beside the table passes '').
     *  An `empty` slot still draws. */
    empty?: string | null;
    ariaLabel?: string;
    /** A tick column that selects (issue #26). */
    selectable?: boolean;
    isSelected?: (row: any) => boolean;
    /**
     * CONTROLLED sort: pass it (null = "no sort") and handle `sort`; the
     * caller orders the rows (a server, or the explorer's sort store). Leave
     * it out and the table sorts the rows itself and remembers the choice.
     */
    sort?: {
        key: string;
        dir: 'asc' | 'desc';
    } | null;
    /** Headers closed, with this sentence as the reason (the explorer's
     *  ranked search results). */
    sortClosed?: string | null;
    /** Rows in groups under headings (the explorer's date headings). The
     *  caller has already ordered them; the table draws them as given. */
    groups?: Group[];
    rowClass?: (row: any, index: number) => string | Record<string, boolean> | undefined;
    /** Attributes for a row (`data-*`, `aria-*`, `draggable`, `tabindex`). */
    rowAttrs?: (row: any) => Record<string, unknown>;
    /** The row's verbs — drawn as ONE labelled Actions control frozen right. */
    rowActions?: (row: any) => ContextAction[];
    /** A test hook for a row's Actions control. */
    rowActionsTestId?: (row: any) => string | undefined;
    /** The trailing column's content width, px (the explorer's ⋮ is 28). */
    actionsWidth?: number;
    /** A card around the table, with the toolbar and pager inside it. The
     *  explorer's listing is not framed — its pane is the frame. */
    framed?: boolean;
    page?: number;
    pageSize?: number;
    total?: number;
    /** Pages, for an endpoint that answers "there is another page" and no
     *  total. */
    pages?: number;
    /** A line in the footer (a count, a note). */
    footNote?: string;
};

declare type __VLS_Props_6 = {
    /** The row's verbs, in the order they should be offered. */
    actions: ContextAction[];
    locale?: LocaleCode;
    /** Overrides the built-in "Actions" / "Aksiyon" label. */
    label?: string;
    /** The whole control is off (a row being saved, a read-only demo). */
    disabled?: boolean;
    theme?: ThemeMode;
    /** A test hook, so a spec can address one row's control without guessing. */
    testid?: string;
};

declare type __VLS_Props_7 = {
    /** The person's notifications (useNotificationFeed), refs unwrapped. */
    feed: NotificationFeed;
    /** The language on screen — any offered code, a language pack's included. */
    locale: string;
    /**
     * Where the administrators' console for notifications is, when the reader
     * may go there. Absent → the second door is not drawn at all.
     */
    manageHref?: string;
};

declare type __VLS_Props_8 = {
    item: NotificationRowData;
    /** The language on screen — any offered code, a language pack's included. */
    locale: string;
};

declare type __VLS_Props_9 = {
    /** The person's notifications (useNotificationFeed), refs unwrapped. */
    feed: NotificationFeed;
    /** The language on screen — any offered code, a language pack's included. */
    locale: string;
};

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 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_2) => 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_2) => 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;
            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_2) => 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_2) => 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;
            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_2) => 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 trash?: boolean | undefined;
                readonly clipped?: Set<string> | undefined;
                readonly extraFilters?: (DriveFilters | null) | undefined;
                readonly extraFiltersOnServer?: boolean | undefined;
                readonly canWrite?: boolean | undefined;
                readonly canPaste?: boolean | undefined;
                readonly selected: Set<string>;
                readonly filters: DriveFilters;
                readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
                readonly folderPreviews?: boolean | undefined;
                readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
                readonly starredIds?: Set<number> | undefined;
                readonly starOverrides?: Map<number, boolean> | 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;
            trash?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            extraFiltersOnServer?: boolean;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            folderPreviews?: boolean;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starOverrides?: Map<number, boolean>;
            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;
            e2eRoot: () => 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;
            trash?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            extraFiltersOnServer?: boolean;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            folderPreviews?: boolean;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starOverrides?: Map<number, boolean>;
            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" | "rowCount" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowPaths" | "e2eRoot" | ("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;
            e2eRoot: () => 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 trash?: boolean | undefined;
                readonly clipped?: Set<string> | undefined;
                readonly extraFilters?: (DriveFilters | null) | undefined;
                readonly extraFiltersOnServer?: boolean | undefined;
                readonly canWrite?: boolean | undefined;
                readonly canPaste?: boolean | undefined;
                readonly selected: Set<string>;
                readonly filters: DriveFilters;
                readonly thumbSrc?: ((n: FileNode) => string | null) | undefined;
                readonly folderPreviews?: boolean | undefined;
                readonly keepBadgeFor?: ((n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null) | undefined;
                readonly starredIds?: Set<number> | undefined;
                readonly starOverrides?: Map<number, boolean> | 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;
            trash?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            extraFiltersOnServer?: boolean;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            folderPreviews?: boolean;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starOverrides?: Map<number, boolean>;
            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;
            e2eRoot: () => 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;
            trash?: boolean;
            clipped?: Set<string>;
            extraFilters?: DriveFilters | null;
            extraFiltersOnServer?: boolean;
            canWrite?: boolean;
            canPaste?: boolean;
            selected: Set<string>;
            filters: DriveFilters;
            thumbSrc?: (n: FileNode) => string | null;
            folderPreviews?: boolean;
            keepBadgeFor?: (n: FileNode) => "kept" | "syncing" | "cloud" | "partial" | null;
            starredIds?: Set<number>;
            starOverrides?: Map<number, boolean>;
            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" | "rowCount" | "dirPerm" | "goUp" | "getPath" | "visibleNodes" | "loadFolder" | "rowPaths" | "e2eRoot" | ("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;
            e2eRoot: () => 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: {
        default?(_: {}): any;
        accepted?(_: {}): any;
        done?(_: {}): any;
        extra?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

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

declare function __VLS_template_4(): {
    attrs: Partial<{}>;
    slots: Partial<Record<`cell-${string}`, (_: {
        row: any;
        value: unknown;
    }) => any>> & Partial<Record<`cell-${string}`, (_: {
        row: any;
        value: unknown;
    }) => any>> & {
        toolbar?(_: {}): any;
        actions?(_: {
            row: any;
        }): any;
        empty?(_: {}): any;
        foot?(_: {}): any;
        'colmenu-extra'?(_: {
            close: typeof closeColMenu;
        }): any;
    };
    refs: {
        listEl: HTMLDivElement;
        colMenuEl: HTMLDivElement;
    };
    rootEl: any;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;

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

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

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

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

/**
 * Where the ticket URL should be fetched from.
 *
 * The server answers `/z/<token>` RELATIVE TO ITS ROOT — it cannot know where
 * its reader sees it. The reader's server root is the manager URL minus
 * `/api/files/manager`, and it keeps its PATH: `/filex` for the admin app
 * under a sub-path (FILEX_BASE_PATH), `https://host.example/files-proxy` for an
 * embed whose host proxies filex under a path of its own. Keeping only the
 * origin (what this did before) sent both to the host's root, where the
 * ticket 404s — a multi-selection ZIP or a drag-out that silently fails.
 *
 * A manager endpoint the host named itself, not ending in
 * `/api/files/manager`, says nothing about the server root; the origin is the
 * best evidence left, as before.
 */
export declare function absoluteTicketUrl(managerUrl: string, ticketUrl: string): string;

/**
 * The `--fe-*` properties an accent colour becomes on the public shell — the
 * ONE derivation, used by the real page (usePublicBranding) and by the admin
 * page's live preview (PublicLinkPreview), so the preview cannot paint a
 * button the page itself would not. `{}` for no (or no valid) accent.
 */
export declare function accentStyleOf(raw: string | undefined | null): Record<string, string>;

/**
 * May a STORED choice stand? Offered, or — while the list has not arrived —
 * merely plausible. After the list arrives only an offered language stands;
 * the stored value itself is kept, so reinstalling the pack brings it back.
 */
export declare function acceptableLocale(code: string | undefined | null): boolean;

/** How long typing must pause before the server is asked. */
export declare const ACCOUNT_CHECK_DELAY_MS = 250;

/**
 * The account menu's rows — the host's own, the explorer's settings rows, and
 * the exit — put in order by ONE rule, for every host that draws the avatar.
 *
 * ⚠⚠ Why this is a module. The web's explorer page folds the explorer's "⋯"
 * into its avatar menu (owner, 2026-09-13: *"`...` bölgesini admin
 * dropdown'ının içine alacağız"* — one menu in that corner, not two), and since
 * 2026-09-27 the desktop app's explorer does the same from `config.account`.
 * The order (the host's doors, then the explorer's settings, then Sign out),
 * the `fe:` prefix and the one hairline above each group are the same decision
 * in both places; written twice it would drift the first time either changed.
 *
 * Pure: no Vue, no DOM.
 */
/** One row of the account menu. */
export declare interface AccountAction {
    key: string;
    label: string;
    /** Draw a hairline above this row. */
    separated?: boolean;
    /**
     * An `actionIcons` key. Absent → the row's own `key` is tried, which is why
     * the explorer's rows (`refresh`, `theme`, `tour`, `shortcut-settings`, …)
     * need no mapping at all: their key IS the glyph's name. A key nothing is
     * drawn for renders an empty box of the same width, so a row with no glyph
     * still lines its label up with the rows that have one.
     */
    icon?: string;
}

/** The check's answer: a field is present only when it would be refused. */
export declare interface AccountCheckAnswer {
    email?: AccountFieldRefusal;
    username?: AccountFieldRefusal;
}

/**
 * A checker for one form: call it with the values in the boxes after every
 * change; it waits until the typing pauses, asks the server once
 * (`ask` - POST /api/auth/account/check through the form's own client) and
 * resolves with the answer. A call a newer one replaced resolves with null,
 * and so does a request that failed: the save still judges, so a check that
 * could not be made says nothing rather than something wrong.
 */
export declare function accountChecker(ask: (q: AccountCheckQuery) => Promise<AccountCheckAnswer>, delayMs?: number): (q: AccountCheckQuery) => Promise<AccountCheckAnswer | null>;

/** What a form asks about: only the fields sent are checked. `for` is whose
 *  account the values are meant for - the caller's own (the default), or an
 *  account an administrator is about to create. */
export declare interface AccountCheckQuery {
    email?: string;
    username?: string;
    for?: 'self' | 'new';
}

/** One field the server would refuse: its code and its sentence. */
export declare interface AccountFieldRefusal {
    error: string;
    message: string;
}

export declare const AccountMenu: DefineComponent<__VLS_Props_11, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (key: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_11> & Readonly<{
onSelect?: ((key: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
btnEl: CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
as: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
id: {
type: StringConstructor;
default: null;
};
}>>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}> | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | null, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, Record<string, any>, VNodeProps & AllowedComponentProps & ComponentCustomProps, {
id: string;
as: string | Record<string, any>;
disabled: boolean;
}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
as: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
id: {
type: StringConstructor;
default: null;
};
}>>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}> | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | null, {}, {}, {}, {
id: string;
as: string | Record<string, any>;
disabled: boolean;
}> | null;
}, any>;

/**
 * The menu, in order: `own` (this account's doors — settings, admin), the
 * explorer's settings rows minus the ones the host has another door for
 * (`omit`), then `tail` (Sign out).
 *
 * ⚠ `omit` is a DROP list, not a keep list: a settings row added to the
 * explorer tomorrow has to arrive in the menu by itself, or the menu silently
 * falls behind the product it belongs to.
 *
 * ⚠ The explorer's rows sit BETWEEN the account's doors and the exit: they are
 * neither "who am I" nor "goodbye", and burying them under Sign out would put
 * the one destructive row in the middle of the list.
 */
export declare function accountMenuRows(own: AccountAction[], explorer: ExplorerMenuRow[], opts?: {
    omit?: Iterable<string>;
    tail?: AccountAction[];
}): AccountAction[];

/** Who the avatar stands for — the fields `personName` reads, plus a picture. */
export declare interface AccountPerson {
    name?: string | null;
    display_name?: string | null;
    username?: string | null;
    email?: string | null;
    /** Profile picture — a small data:image/… URI or a URL. */
    avatar_url?: string | null;
    /** `admin` for an administrator — what decides whether a host offers its
     *  console door. Never a security boundary: the server checks again. */
    role?: string | null;
}

/** See `ExplorerConfig.accountSearch`. */
export declare interface AccountSearchHook {
    /** The account THIS explorer is mounted for — heads its own group. */
    self: SearchAccount;
    /** Every OTHER account signed in right now. Read on each query, so an
     *  account added or signed out while the explorer is mounted counts. */
    others: () => SearchAccount[] | Promise<SearchAccount[]>;
    /** `/api/files/search` on that account's server, with its credential. */
    search: (accountId: string, query: string, opts: {
        limit: number;
        scope: GlobalSearchScope;
    }) => Promise<GlobalSearchHit[]>;
    /**
     * Open another account's hit — the host switches to that account. The hit
     * arrives ADDRESSED (`name://rel`, as a listing row carries it): the host
     * never re-derives where a file is.
     */
    open: (accountId: string, item: SearchHitItem) => void | Promise<void>;
    /** Download another account's hit. Absent: its rows offer no Download. */
    download?: (accountId: string, item: SearchHitItem) => void | Promise<void>;
    /** Drag another account's hit out to the OS. Absent: its rows do not drag. */
    dragStart?: (accountId: string, items: SearchHitItem[]) => void | Promise<unknown>;
}

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

/** The account zone remembered in this browser by the last session. */
/**
 * The settings dialog's handle on ONE owner's account zone: read it, and set it
 * the way a person's own pick is set — remembered for the next first paint,
 * and clearing this browser's VIEWER pick, which outranks the account and
 * would otherwise make the control visibly do nothing (the viewer tier is what
 * an embed's "⋯ → Time zone" writes). `''` = this device's zone.
 *
 * ⚠ One function for both hosts of the dialog: the admin app passes its own
 * owner (web/src/lib/timezone.ts), the explorer passes the owner it registered
 * the account's zone under (useExplorerTimeZone) — the desktop app's dialog.
 */
export declare function accountZoneControl(owner: symbol): {
    get: () => string;
    set: (tz: string) => void;
};

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

/**
 * Every palette a person may pick: the built-ins, then the instance's own.
 *
 * ⚠ Operator themes come LAST and are never interleaved. The built-in order
 * is the order of the gallery cards people have learned, and a theme named
 * "Amber Kurumsal" sorting itself between Amber and Lilac would move the card
 * under somebody's cursor the first time a theme was added.
 */
export declare function allThemes(): ThemeDef[];

export declare interface AnchoredPanelPosition {
    top: string;
    /** Distance from the viewport's right edge — left-to-right interfaces. */
    right?: string;
    /** Distance from the viewport's left edge — right-to-left interfaces. */
    left?: string;
    /** Present only when a width was asked for. */
    width?: string;
    /** Room left under the anchor, for a scrolling list inside the panel. */
    maxHeight: string;
}

export declare interface AnchorOptions {
    /** The panel's preferred width in px; clamped to the viewport. */
    width?: number;
    /** Minimum distance from the viewport's edges. */
    gutter?: number;
    /** Gap between the button's bottom and the panel's top. */
    gap?: number;
    /** Ceiling for `maxHeight`. */
    maxHeight?: number;
    /** The direction the header is drawn in (core `dirOfElement(button)`). */
    dir?: 'ltr' | 'rtl';
}

export declare function anchorUnderEndEdge(rect: {
    bottom: number;
    right: number;
    left?: number;
}, viewport: {
    width: number;
    height: number;
}, opts?: AnchorOptions): AnchoredPanelPosition;

/** Is any row of this selection frozen by an app? */
export declare function anyLocked(nodes: readonly Pick<FileNode, 'locked' | 'lock'>[]): boolean;

/**
 * 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;
    /**
     * The level of each permission the key holds, as the server answers it -
     * `{comments: 'read' | 'rw'}`. A key whose list does not name a permission
     * holds its default, and the server is where that rule lives; absent only
     * from an older server.
     */
    permissions?: Record<string, 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.
     * `comments:rw` lets the key add and delete comments too; without it the
     * key reads them (`write` does not include it).
     */
    scopes?: string;
    expires_in_days?: number;
}

/** The meta tag's name. Mirrors spa_shell.go. */
export declare const APP_BASE_META = "filex-base";

/** The base this document was served under: `''` at the root, else `/filex`. */
export declare function appBase(): string;

/** A file the interface was opened with. `path` is adapter-qualified. */
declare interface AppFrameFile {
    path: string;
    name: string;
    size?: number;
    mime?: string;
    /** Cannot be written (read-only storage, view-only opening). */
    readOnly?: boolean;
}

/** What the rule sees of a selected row. */
declare interface AppliesItem {
    kind: 'file' | 'dir' | string;
    /** Lower-case, no dot. */
    ext?: string | null;
    mime?: string | null;
    /** BARE state keys the asking plugin keeps on this item (prefix stripped). */
    state?: string[];
}

/** Reduce a listing row to what the rule reads. */
export declare function appliesItemOf(node: AppliesNodeLike, plugin?: string): AppliesItem;

/** The rule against a selection already reduced to items. */
export declare function appliesMatches(rule: PluginApplies | null | undefined, items: AppliesItem[]): boolean;

/** A listing row, as the explorer holds it — only the three fields matter. */
declare interface AppliesNodeLike {
    type?: string;
    extension?: string | null;
    mime_type?: string | null;
    basename?: string;
    /** `<plugin>:<key>` as the listing carries it. */
    app_state?: string[];
}

/**
 * The rule against listing rows. `plugin` is the ASKING action's plugin —
 * without it a `state` / `no_state` rule can never be satisfied, so pass it
 * wherever the action is known.
 */
export declare function appliesToNodes(rule: PluginApplies | null | undefined, nodes: AppliesNodeLike[], plugin?: string): boolean;

/**
 * v2 — an app plugin holds a file read-only (`files:lock`,
 * docs/APP-PLUGINS-API.md → "File locks"). The row's `perm` arrives capped
 * at `viewer` for EVERYONE, administrators included, so nothing else has to
 * know about locks to behave; this is what the badge says out loud.
 */
export declare interface AppLock {
    /** The app holding it — its manifest `name`, which is what ADDRESSES it. */
    plugin: string;
    /**
     * The same app as a person should read it ({"en": "e-Signature"}), in every
     * language its manifest wrote it in.
     *
     * ⚠ Absent where the server cannot resolve the name (the app was removed,
     * or there is no app runtime), and then `plugin` is what is shown — which
     * is what every surface did before this field existed, and read as "sign
     * locked this file" where the rest of the product says "e-Signature"
     * (v0.43.0).
     */
    plugin_label?: PluginText;
    reason?: string;
    /** The reason in every language the app wrote it in (a manifest message);
     *  the reader's own is shown, `reason` is the plain fallback. */
    reason_text?: PluginText;
    /** RFC 3339; absent means "until the app lifts it". */
    until?: string | null;
}

/**
 * The account's density has arrived: apply it, without sending it back.
 *
 * Fires the same `filex:density` event a click would, so an explorer already
 * on screen re-lays-out instead of waiting for a navigation.
 */
export declare function applyAccountDensity(d: string | undefined | null): void;

/**
 * Paint a palette this person did not choose — the instance's own default,
 * applied to somebody who has never expressed a preference.
 *
 * ⚠⚠ It records NOTHING: not the account, not this browser's mirror. An
 * instance default is the operator's standing answer, not a personal choice,
 * and the difference is load-bearing in both directions. Written to the
 * account, it would overwrite on one device a choice the person made on
 * another. Written to the mirror, it would make `hasOwnChoice()` true, so the
 * day the operator picks a different house theme every existing person would
 * stay pinned to the old one, permanently, with no way to tell why.
 */
export declare function applyInstanceDefault(id: string | undefined | null): void;

/**
 * Type-as-you-go shaping. Returns what the field should hold after this
 * keystroke — never an error: a rule refuses a CHARACTER here, and says why
 * only in `ruleError` once there is something to judge.
 */
export declare function applyRule(raw: string, rule: PdfFieldRule | null): string;

/**
 * The account's palette has arrived: paint it, without sending it back.
 *
 * ⚠ Separate from `setTheme` on purpose. Echoing a value that came FROM the
 * server back TO it is how a hydration turns into a write, and a write into
 * another device's surprise.
 *
 * ⚠⚠ `plausibleThemeId`, not `themeById` — the second merge repair, and the
 * race it closes is worth spelling out. The account's answer and the operator
 * themes are two independent fetches with no ordering between them. When the
 * account arrives first and says `custom:acme`, `themeById` cannot know that
 * id yet (the list is still in flight), would call it invalid, and would drop
 * the person onto the stock palette — writing that demotion into this
 * browser's mirror. `setCustomThemes` then finds the selection already at the
 * default and sees nothing to correct, so the choice is gone rather than
 * restored. Holding a prefixed id on trust and letting the list resolve it for
 * real is the same contract `readStoredThemeId` already follows at boot.
 */
export declare function applyStoredPalette(id: string | undefined | null): void;

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

/**
 * THE ESCAPE HATCH — "Apply to all folders".
 *
 * Makes the setup on screen the person's DEFAULT and forgets every folder's
 * own memory, so every folder now opens the way this one does — which is what
 * the words promise. ⚠ It has to WRITE the default now: the old model got this
 * for free because every click already wrote a global default, and that free
 * write is the leak this file exists to close.
 */
export declare function applyToAllFolders(view: FolderViewDefault): void;

/** The app interfaces that open this file, in the server's order. */
export declare function appViewersFor(views: readonly PluginViewRow[], node: NodeLike): PluginViewRow[];

declare type ArchiveCreateFormat = 'zip' | '7z' | 'tar' | 'tar.gz' | 'tar.bz2' | 'tar.xz';

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

/**
 * archiveFormatLabel — how an archive format is written wherever a person
 * reads it: the create dialog, the admin Archives page, its provider cards.
 *
 * Upper case (ZIP, TAR.GZ, RAR), except 7z, which its own project writes in
 * lower case. One rule in one place: the dialog wrote "7z" while the admin
 * page wrote "7Z" for the same format (measured, 0.44.0 integration of #48).
 */
export declare function archiveFormatLabel(format: string): string;

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

/** Attach the HTTP transport (a no-op when one is already attached). */
export declare function attachViewPrefsHttp(opts: ViewPrefsHttpOptions): void;

/**
 * Hand this module its transport and read the document. Calling it again is a
 * no-op: two explorers on one page share this module's state, and the admin
 * app attaches before the explorer it hosts does.
 */
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;
};

/**
 * Every language on offer, built-ins first and the rest in the order the
 * server listed them — so the two the product ships do not move around when
 * an app is installed. ⚠ THE one list every picker reads (the admin
 * header's switcher, the settings dialog, the public shell).
 */
export declare function availableLocales(): PublicLocaleOption[];

/** base64url (padded or not) to bytes - what `applicationServerKey` takes. */
export declare function base64UrlToBytes(s: string): Uint8Array<ArrayBuffer>;

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

export declare type BrowserNotifyPermission = 'granted' | 'denied' | 'default' | 'unsupported';

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

/** The languages this package ships a full catalogue for. */
export declare const BUILTIN_LOCALES: readonly LocaleCode[];

/** filex's own viewer, as a handler id (and "Open with"'s choice of it). */
export declare const BUILTIN_VIEWER = "builtin";

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';

export declare function canMoveColumn(id: ColumnId, delta: -1 | 1): boolean;

export declare interface Capabilities {
    /** Folder previews are on (Settings; default on): pictures on folder
     *  cards and the list of what a folder holds when the pointer rests on it.
     *  Absent (an older server): on. */
    folder_previews?: boolean;
    /** Which filex answered, in one line (`v0.47.0 (<commit>, <built>)`). */
    version?: string;
    /** 0.54 (#211, audit A11): the release alone (`v0.54.0`) — the line the
     *  account menu ends with — and the commit and build time beside it. A
     *  part the build did not stamp is absent; nothing parses `version`. */
    release?: string;
    commit?: string;
    built?: string;
    /** 0.54 (#211): how each kind of file is edited and the numbers an input is
     *  held to — the server's rules, held by lib/serverRules. */
    edit_kinds?: EditKinds;
    limits?: ServerLimits;
    /** 0.54 (#211, audit B16): the notification events that cannot happen
     *  here, by event (lib/serverRules `EventOff`). */
    event_off?: Record<string, EventOff>;
    /** The public demo: nothing a visitor changes may be saved (the settings
     *  dialog greys its saves). */
    demo_mode?: boolean;
    /** Virus scanning is on. (Whether the "virus found" notification can
     *  happen is the server's own answer, `event_off`.) */
    antivirus?: boolean;
    /** 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[];
    /** Drafts (issue #71): present when the server keeps drafts for THIS caller
     *  (a person acting for themselves — not an app token, not a caller
     *  confined to one folder). New document then makes a draft; absent, it
     *  creates the file directly. `limit` is how many one person may keep. */
    drafts?: {
        limit: number;
    };
    ffmpeg?: boolean;
    ghostscript?: boolean;
    onlyoffice_url?: string | null;
    drawio_url?: string | null;
    max_chunk_mb?: number;
    upload_limit_mb?: number;
    /** Longest life a new share link may be given on this install, in days
     *  (0 = no ceiling) - the administrator's setting. */
    share_max_ttl_days?: number;
    /** Longest life a new link made by THIS caller may be given, in days (0 =
     *  no ceiling): the install's ceiling or the permission rules binding them
     *  (ShareLinkMaxDays), whichever is shorter. Read by the share dialog so it
     *  offers only expiries the server keeps for this person. */
    share_link_max_days?: number;
    /** Archive creation policy. Absent on servers older than archive providers.
     *  `allowed_formats` is what this server can actually make (every format
     *  but a plain ZIP needs 7-Zip there); empty means it can make none, and
     *  `encryption` says whether a password can be set. */
    archive?: {
        enabled: boolean;
        default_format: ArchiveCreateFormat | '';
        allowed_formats: ArchiveCreateFormat[];
        encryption?: boolean;
    };
    /** 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';
    /** Could this caller set up a missing optional service (ONLYOFFICE,
     *  draw.io…)? An administrator who can reach the instance
     *  settings — not a tenant admin, not an API token. Decides between "greyed
     *  with where to fix it" and "not offered" (lib/serviceGate). Absent on an
     *  older server, which reads as "no". */
    caller_admin?: boolean;
    /** App plugins (docs/APP-PLUGINS-API.md). Absent or `enabled: false` → the
     *  explorer makes no plugin request at all. */
    app_plugins?: {
        enabled: boolean;
    };
    /** 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;
    };
    /** Can outgoing mail be sent right now (SMTP configured AND verified)?
     *  Absent on an older server or one with no mailer wired — read as "yes",
     *  i.e. keep offering mail the way it always was. */
    mail?: {
        ready: boolean;
    };
    /** The changes this server runs as jobs of its operations queue when asked
     *  with `queued=1`: `rename` (POST /api/files/manager?action=rename) and
     *  `restore` (POST /api/files/manager/restore, a `node_ids` batch). Absent on
     *  an older server, which changes inside the request. */
    queued?: Array<'rename' | 'restore' | (string & {})>;
    /** 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;
    };
    /** wiring:e2 policy — who may START encrypting here (backend
     *  internal/e2epolicy): `available` is the platform operator's switch for
     *  the caller's tenant, `policy` the tenant's choice — `off` | `admins` |
     *  `permitted` | `approval`. Absent for an anonymous caller and on a server
     *  older than the policy, which reads as before: the explorer offers
     *  encryption and the server decides.
     *
     *  ⚠ The CALLER'S OWN tenant's row. The platform operator, looking at
     *  another tenant's storage, is answered by THAT tenant's policy and ceiling
     *  (`POST /api/files/e2e/allowed`), which can differ either way — so nothing
     *  is hidden from this field; only the per-path answer hides a door. */
    e2e_policy?: {
        available: boolean;
        policy: string;
    };
    /** wiring:e2 vault — the server has the vault API (`/api/files/e2e/vault/*`,
     *  docs/E2E-VAULT-FORMAT.md): level 3 is offered for a new folder only
     *  here. Absent or false: the level is not drawn at all. */
    e2e_vault?: boolean;
}

/** The server's `coverage` object (sync.CatalogueCoverage). */
export declare interface CatalogCoverage {
    complete: boolean;
    reason?: CoverageReason | string;
    /** `lazy` for a lazily cataloged storage. */
    mode?: string;
    /** The lazy behaviour: `background` (A) or `on_open` (B). */
    fill?: string;
    catalogued_folders?: number;
    pending_folders?: number;
    watched_folders?: number;
    max_watches?: number;
    filler?: string;
    held_back_folders?: number;
    reconciles?: number;
}

/**
 * A new password for a `.fxe`. Proof is the current password or the recovery
 * key. Only the password slot changes; the recovery key, the escrow slot, the
 * DEK — and so every byte of the body — stay as they are. Throws
 * E2eDecryptError for a wrong credential.
 */
export declare function changeFxePassword(h: FxeHeader, cred: E2eCredential, newPassword: string): Promise<FxeHeader>;

export declare const ChoiceButtons: DefineComponent<__VLS_Props_18, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (v: string | string[]) => any;
}, string, PublicProps, Readonly<__VLS_Props_18> & Readonly<{
"onUpdate:modelValue"?: ((v: string | string[]) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare interface ChoiceOption {
    value: string;
    label: string;
    /** A second line under the label — what choosing this one means. */
    help?: string;
    /** This one answer is not available (the others are). The button stays on
     *  screen — a choice that vanishes cannot tell the person it exists — and
     *  `help` is where to say why. The tag picker's "Team" for a viewer is the
     *  first user. */
    disabled?: boolean;
    /** An icon drawn before the label (and instead of it with `iconOnly`). */
    icon?: Component;
}

export declare const ChoiceSelect: DefineComponent<__VLS_Props_19, {
focus: () => void | undefined;
open: typeof show;
close: typeof close_3;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
invalid: (ev: Event) => any;
change: (v: Value) => any;
"update:modelValue": (v: Value) => any;
}, string, PublicProps, Readonly<__VLS_Props_19> & Readonly<{
onInvalid?: ((ev: Event) => any) | undefined;
onChange?: ((v: Value) => any) | undefined;
"onUpdate:modelValue"?: ((v: Value) => any) | undefined;
}>, {
invalid: boolean;
name: string;
size: "sm" | "md" | "lg";
id: string;
disabled: boolean;
testid: string;
placeholder: string;
modelValue: Value | null;
ariaLabelledby: string;
ariaLabel: string;
required: boolean;
ariaDescribedby: string;
requiredMessage: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
trigger: HTMLButtonElement;
hidden: HTMLInputElement;
panel: HTMLUListElement;
}, HTMLSpanElement>;

/** The levels a folder can be GIVEN, in order (level 1 first — the default).
 *  wiring:e2 vault - the vault (level 3) is offered only where the server
 *  has its API (`capabilities.e2e_vault`), and only to a NEW folder: an
 *  existing one is never converted (`choosableLevels`). */
declare type ChoosableLevel = 'content' | 'names' | 'vault';

/**
 * Like `openAlongInline`, without the flip: the box starts at `anchor` and is
 * only pushed back inside the viewport (popovers that hang from a chip and
 * must stay beside it). Same mirror construction.
 */
export declare function clampAlongInline(anchor: number, size: number, viewport: number, dir: TextDirection, margin?: number): number;

/** Inside the page, at least the minimum size, no NaN. */
export declare function clampFrac(r: FracRect): FracRect;

/** What a stored name is, from its spelling alone (no key needed). */
export declare function classifyStoredName(stored: string): StoredName;

/** The CLDR cardinal categories in the order a message lists its forms. */
export declare const CLDR_ORDER: readonly ["zero", "one", "two", "few", "many", "other"];

/**
 * Forget every remembered answer on this browser: each open explorer's, and
 * every key this module wrote, whoever it belonged to. A sign-out runs it
 * (lib/prefs forgetPersonalPrefs); a host with a sign-out of its own that does
 * not go through there may call it.
 */
export declare function clearMenuAnswers(): void;

/** Forget every choice. */
export declare function clearOpenWithChoices(): void;

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

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

/** `s` cut to `max` characters, never inside a surrogate pair. */
export declare function clipRunes(s: string, max: number | undefined): string;

declare function close_2(returnFocus: boolean): void;

declare function close_3(refocus?: boolean): void;

declare function closeColMenu(): void;

/**
 * What is remembered about one table's columns. Short keys on purpose — the
 * explorer keeps one of these per folder and the whole document is
 * re-serialised on every save.
 */
export declare interface ColsState<Id extends string = string> {
    /** Widths the person set, px. A column absent here is at its shipped width. */
    w: Partial<Record<Id, number>>;
    /** Columns the person switched off. */
    hidden: Id[];
    /** The person's order. Absent = the order the columns were declared in. */
    o?: Id[];
}

/** Where a store reads and writes its state. */
export declare interface ColumnBacking<Id extends string = string> {
    /** The stored state, or anything that does not parse as one (read as empty). */
    get(): unknown;
    /** Replace it. The store always hands over a complete, normalised state. */
    set(next: ColsState<Id>): void;
    /**
     * Is there anything here the person could RESET? Optional — by default,
     * "the state says something". The explorer's folder backing answers "does
     * THIS folder have columns of its own", because a folder that shows the
     * person's default columns has nothing of its own to reset, and a "Reset
     * columns" row that does nothing when clicked reads as broken.
     */
    customised?(): boolean;
}

/** The stretch of an order a movable explorer column may occupy. */
export declare function columnDropBand(order: readonly ColumnId[]): {
    lo: number;
    hi: number;
};

export declare function columnHidden(id: ColumnId): boolean;

/**
 * The explorer's columns, in the order the list draws them.
 *
 * `name` is the table's LEAD: pinned first, never hidden, never moved, but
 * sized by the person like every other column (the owner: "istersem name'i de
 * kısabilir olmalıyım"). The star is a control, not a value: not hideable, not
 * resizable, pinned last beside the row menu.
 */
export declare type ColumnId = 'name' | 'type' | 'location' | 'owner' | 'modified' | 'remaining' | 'size' | 'star';

export declare function columnOrder(): ColumnId[];

/**
 * The row's tracks, in shipped order.
 *
 * ⚠⚠ There is no `priority` field and nothing is shed for width: the owner
 * rejected a table that dropped columns and said "no room" — "kenara devam
 * eden bir scroll getirsin". A table wider than its pane scrolls sideways.
 */
export declare const COLUMNS: readonly ColumnSpec[];

export declare function columnsCustomised(): boolean;

export declare type ColumnSpec = TableColumnSpec<ColumnId>;

export declare interface ColumnStore<Id extends string = string> {
    readonly lead: Id;
    specs(): readonly TableColumnSpec<Id>[];
    spec(id: Id): TableColumnSpec<Id> | undefined;
    /** The full order, lead first, reconciled with the columns that exist. */
    order(): Id[];
    width(id: Id): number;
    setWidth(id: Id, px: number): void;
    hidden(id: Id): boolean;
    setHidden(id: Id, hidden: boolean): void;
    /** Put `id` at `index` in the order — `index` is where it ENDS UP. */
    move(id: Id, index: number): void;
    /** Has anybody ever sized this table? (the lead's width is the bit) */
    widthsAreAuto(): boolean;
    /** Commit the widths on screen for every column that has none stored. */
    freeze(widths: Partial<Record<Id, number>>): void;
    /** Back to the shipped widths, order and visibility. */
    reset(): void;
    /** Has anything about the columns been changed by hand? */
    customised(): boolean;
    /** The state as it resolves right now — what "Apply to all folders" copies. */
    state(): ColsState<Id>;
    layout(available: number, candidates: readonly Id[], metrics?: LayoutMetrics): GenericTableLayout<Id>;
}

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;

/**
 * Does `cond` hold against the surface's values?
 *
 * ⚠ An absent condition HOLDS. `show_when: null` is "always", which is what
 * every field without one means, so the two paths do not diverge.
 */
export declare function conditionMet(cond: PluginCondition | null | undefined, values: Record<string, unknown>): boolean;

export declare function configurePrefs(next: PrefsConfig): void;

/** Is the server unreachable right now, as far as this page has seen? */
export declare const connectionDown: ComputedRef<boolean>;

/** When it first went (epoch ms), or 0. For a caller that wants to wait. */
export declare const connectionDownSince: ComputedRef<number>;

/**
 * How many background failures the shared notice is standing in for. The
 * notice does not print it — a number that climbs is the storm again, in one
 * line — but a test can assert that many failures made one notice.
 */
export declare const connectionFolded: ComputedRef<number>;

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

export declare const ConnectionNotice: DefineComponent<__VLS_Props_33, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_33> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

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).
 *
 * ⚠ Rungs 2 and 3 keep the API base's PATH. filex can live under a sub-path
 * (`https://example.com/filex`, FILEX_BASE_PATH): the desktop app then has
 * that as its apiBase and the admin app `/filex`, and a guide that kept only
 * the origin printed `https://example.com/dav/` — the host's root, not filex.
 *
 * ⚠⚠ 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_46, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (err: {
message: string;
}) => any;
close: () => any;
}, string, PublicProps, Readonly<__VLS_Props_46> & Readonly<{
onError?: ((err: {
message: string;
}) => any) | undefined;
onClose?: (() => 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;
}

export 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;
    /**
     * A test hook on the menu ITEM. The menu teleports to <body>, so an
     * entry cannot be addressed through the component that opened it; a spec
     * (or a plugin's own e2e) that used to click a loose row button needs a
     * name for the verb now that the verb lives in here. Absent for every
     * explorer action, which are addressed by label.
     */
    testid?: string;
    /**
     * 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 ConvertIo {
    /** The raw listing of a folder. */
    list(dirWire: string): Promise<ConvertRow[]>;
    /** The first bytes of a file (at least 9 when it has them). */
    head(wire: string): Promise<Uint8Array>;
    /** The whole file. */
    read(wire: string): Promise<ArrayBuffer>;
    /**
     * Write `data` over the file `row` in `dirWire` as a conversion write, on
     * condition that it is still the file listed (`expect`: "<size>:<ms>").
     * Throws when the server refuses (a changed file: 412).
     */
    write(dirWire: string, row: ConvertRow, data: Blob, expect: string | null): Promise<void>;
    /** Encrypt one file's bytes under the folder key. */
    encrypt(data: ArrayBuffer): Promise<ArrayBuffer>;
    /**
     * A file over `maxBytes` (the one-shot limit): read, encrypted as a STREAM
     * (header 0x02) file and written over itself as a conversion write on the
     * same condition as `write` - all as streams, so memory stays at a few
     * chunks whatever the size. Resolves false when this server cannot take it
     * from this browser (no staged upload, and too big to gather for a single
     * POST); throws when it failed (changed meanwhile: 412, no permission, …).
     * Absent: such files are left as they are and counted in `tooBig`.
     */
    writeLarge?(dir: string, row: ConvertRow, expect: string | null): Promise<boolean>;
    /** Asked between files. */
    stopped(): boolean;
}

export declare interface ConvertOptions {
    /** The one-shot limit: files larger than this go through `io.writeLarge`
     *  (STREAM, 0x02), or are counted in `tooBig` when there is none. */
    maxBytes: number;
}

export declare interface ConvertProgress {
    /** Files found (everything but the key file and name sidecars). */
    total: number;
    /** Converted by this run. */
    done: number;
    /** Already encrypted — converted earlier, or uploaded encrypted. */
    skipped: number;
    /**
     * Over the one-shot limit and NOT converted: this server cannot take a file
     * sent in pieces, and it is too big to gather for one POST (or the caller
     * has no streamed write at all). Left as they are.
     */
    tooBig: number;
    /** Of `done`, files over the one-shot limit, written as STREAM (0x02). */
    large?: number;
    /** Could not be read or written (changed meanwhile, no permission, …). */
    failed: number;
}

/**
 * e2econvert — encrypt a folder that already exists, in place
 * (docs/E2E-ENCRYPTION.md → "Encrypting a folder you already have").
 *
 * The key file is written first (e2ecrypto `startConversion`: v3, `conv`
 * required and pending), which makes the folder an encrypted folder to the
 * server from that moment. Then this walks it: every file whose bytes do not
 * start with the `filexe2e` magic is read, encrypted under the folder key and
 * written back over itself as a CONVERSION WRITE — one the server keeps no
 * version of, because what it replaces is the plaintext being removed.
 *
 * A file over the one-shot limit (200 MB) is converted too, as a STREAM
 * (header 0x02) file read, encrypted and written as streams (`writeLarge`);
 * it is left as it is only where the server cannot take it from a browser.
 *
 * Idempotent and resumable by the magic: a file already converted is left
 * alone, so running this again after a stop, a reload or a failure continues
 * it. A large file stopped half-way is not half-converted: its write is one
 * upload that replaces the file only when it commits, so until then the
 * server still has the whole plaintext and the next run starts it over. A write is conditional on the file being the one that was listed
 * (`expect`), so a file changed meanwhile is not overwritten with an older
 * version of itself — it counts as failed, and the next run picks it up.
 *
 * Names are not touched here: at level 2 the name pass (lib/e2enamepass)
 * runs after it. Pure over an `io` object, like the name pass.
 */
export declare interface ConvertRow {
    path: string;
    basename: string;
    type: 'file' | 'dir';
    /** Bytes, as listed. */
    size?: number;
    /** Milliseconds, as listed — with the size, the write's precondition. */
    last_modified?: number;
}

/** `storage_info` → storage name → its incomplete coverage (null = complete). */
export declare function coverageByStorage(info: unknown): Record<string, CatalogCoverage | null>;

/** A coverage object worth telling anybody about, or null. */
export declare function coverageIncomplete(c: CatalogCoverage | null | undefined): CatalogCoverage | null;

/** The sentence one storage's coverage is told in: a catalog key and its values. */
export declare function coverageMessage(c: CatalogCoverage): {
    key: string;
    vars: Record<string, number>;
};

/** What the banner over a listing or a search says, and whether it offers an action. */
export declare interface CoverageNotice {
    key: string;
    vars: Record<string, string | number>;
    /** The storage the notice is about, when it is about one. */
    storage?: string;
    /** Offer "Catalog everything" (an administrator, behaviour B). */
    offerCatalogAll: boolean;
}

/**
 * The notice for what is on screen.
 *
 *   - A listing, or a search inside one storage: that storage's coverage.
 *   - A search that spans every storage (the server searches them all when
 *     the query is typed at a storage's root and there is more than one):
 *     the names of the ones not fully cataloged.
 *
 * `admin` decides the action only; everybody reads the same sentence.
 */
export declare function coverageNotice(opts: {
    map: Record<string, CatalogCoverage | null>;
    adapter: string;
    searching: boolean;
    crossStorage: boolean;
    admin: boolean;
}): CoverageNotice | null;

/**
 * The share of the folders found so far that are cataloged, 0–99 while any
 * is still waiting (a floor, so "100%" is never shown beside a notice that
 * says the work is not done).
 */
export declare function coveragePercent(c: CatalogCoverage): number;

/**
 * catalogCoverage — how much of a storage its catalog covers, as the server
 * says it, and the one set of rules every view draws that by.
 *
 * filex keeps a catalog of every storage, and search, folder sizes and drive
 * usage are answered from it. While it does not cover a storage in full the
 * server says so (docs/LAZY-CATALOGUE.md → "Coverage in the UI"):
 *
 *   - `first_scan`   — any storage whose first sync has not finished;
 *   - `lazy_filling` — a lazily cataloged storage whose background pass is
 *                      still going (behaviour A);
 *   - `lazy_on_open` — a lazily cataloged storage that catalogs only the
 *                      folders people open (behaviour B).
 *
 * The listing and search responses carry it per storage in `storage_info`,
 * drive usage per row. A folder row whose own size leaves something out
 * carries `size_partial` (see useLocale `formatNodeSize`).
 *
 * ⚠ One module for the whole explorer: the banner over a listing, the banner
 * over search results and Home's drive cards read the SAME object through the
 * SAME rules, so they cannot tell a person two different things about one
 * storage.
 */
/** Why a storage's catalog is not complete. */
export declare type CoverageReason = 'first_scan' | 'lazy_filling' | 'lazy_on_open';

/**
 * A column store over `specs`, reading and writing through `backing`.
 *
 * `lead` is the column pinned first: never hidden, never moved, always
 * resizable. It is the one that says WHICH ROW this is — the explorer's Name,
 * an admin table's email or path — and the table freezes it on the left edge
 * while the others scroll.
 *
 * ⚠ The state is read through a `computed`, so a store created inside a
 * component re-renders it when the backing changes (the explorer's backing
 * changes every time the folder does) and parses the stored document once per
 * change rather than once per cell.
 */
export declare function createColumnStore<Id extends string>(specsOf: () => readonly TableColumnSpec<Id>[], backing: ColumnBacking<Id>, opts?: {
    lead?: Id;
}): ColumnStore<Id>;

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;
    /** The name key, when the folder was created with encrypted names. */
    names?: E2eNameKey;
}

declare interface CreatedFxe {
    header: FxeHeader;
    /** The whole `.fxe`: prefix, then the body as the source is read. */
    stream: ReadableStream<Uint8Array>;
    /** Bytes the stream will carry. */
    size: number;
    /** Show this ONCE. filex never stores it. */
    recoveryKey: string;
    /** Keys for this tab's ring, so the new file opens without a prompt. */
    key: FxeKey;
}

/**
 * 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;
    /**
     * Encrypt file and folder names too (marker v3, feature `names`). The
     * default for a new folder in the UI; false keeps the v2 content-only
     * folder that every filex since 0.31 can open.
     */
    encryptNames?: boolean;
}

/**
 * Encrypt `src` (exactly `plainSize` bytes, named `name`) into a `.fxe`.
 * The password slot, recovery key and escrow slot are made exactly as for a
 * new encrypted folder (`createEncryptedFolder`); the stream errors if the
 * source is not `plainSize` bytes long.
 */
export declare function createFxe(name: string, plainSize: number, src: ReadableStream<Uint8Array>, password: string, opts?: CreateFxeOptions): Promise<CreatedFxe>;

export declare interface CreateFxeOptions {
    /** Base64 SPKI of the installation's escrow key, when it has one. */
    escrowPublicKey?: string | null;
    iterations?: number;
    /** Chunk size, log2. Tests only: writers use E2E_STREAM_CHUNK_LOG2. */
    chunkLog2?: number;
    onProgress?: (plainBytes: number) => void;
}

/**
 * Tiny per-explorer key ring: encrypted-folder root (wire path) → FMK, and
 * the folder's name key when its names are encrypted.
 * 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, names?: E2eNameKey | null, previous?: CryptoKey | null): void;
    /** The previous FMK of a folder mid re-key (files not re-wrapped yet). */
    previous(root: string): CryptoKey | undefined;
    /** A re-key finished: the previous FMK is no longer needed. */
    dropPrevious(root: string): void;
    /** The folder's name key; undefined for a content-only folder or a locked one. */
    names(root: string): E2eNameKey | undefined;
    setNames(root: string, names: E2eNameKey): void;
    /** Every unlocked root, for resolving a path from any view. */
    roots(): string[];
    /** Drop one folder's keys ("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;
}>;

/**
 * The feed's state and verbs. See the file note for why this is not a store.
 */
export declare function createNotificationFeed<T extends NotificationRowData>(opts: NotificationFeedOptions<T>): {
    feed: Ref<T[], T[]>;
    feedLoading: Ref<boolean, boolean>;
    unreadCount: Ref<number, number>;
    hasUnread: ComputedRef<boolean>;
    mine: Ref<T[], T[]>;
    mineTotal: Ref<number, number>;
    mineLimit: Ref<number, number>;
    mineOffset: Ref<number, number>;
    mineUnreadOnly: Ref<boolean, boolean>;
    mineLoading: Ref<boolean, boolean>;
    mineError: Ref<string | null, string | null>;
    panelOpen: Ref<boolean, boolean>;
    refreshFeed: () => Promise<boolean>;
    fetchUnread: () => Promise<void>;
    syncUnread: () => Promise<void>;
    acceptCount: (count: number) => Promise<void>;
    fetchMine: () => Promise<void>;
    setMinePage: (p: number) => void;
    setMineUnreadFilter: (u: boolean) => void;
    openPanel: () => void;
    closePanel: () => void;
    markRead: (id: number) => Promise<void>;
    markAllRead: () => Promise<void>;
};

export declare function createStorageWatch(io: {
    /** GET /api/admin/storages. */
    list(): Promise<WatchedStorageRow[]>;
    pollMs?: number;
    giveUpAfter?: number;
}): StorageWatch;

/** STREAM body in, plaintext out. Errors with E2eDecryptError on any tampering. */
export declare function createStreamDecryptor(key: CryptoKey, prefix: Uint8Array, log2?: number, opts?: StreamDecryptOptions): TransformStream<Uint8Array, Uint8Array>;

/** Plaintext in, STREAM body out. */
export declare function createStreamEncryptor(key: CryptoKey, prefix: Uint8Array, log2?: number, opts?: StreamEncryptOptions): TransformStream<Uint8Array, Uint8Array>;

export declare function createWebPush(api: WebPushApi, env: WebPushEnv): WebPushController;

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

/** The preferences as they stand — the server's answer once it has landed. */
export declare function currentPrefs(): UiPrefs;

/**
 * tema:v1 — the prefix that keeps the two namespaces apart.
 *
 * An operator-defined theme's id is always `custom:<slug>`, so no name an
 * operator types can ever shadow `night`, `forest` or `default`. The server
 * stores the slug bare and adds the prefix on the way out
 * (backend/internal/api/handlers/themes.go).
 */
export declare const CUSTOM_THEME_PREFIX = "custom:";

/** One column of a table. */
export declare interface DataColumn<Row = any> {
    /** Stable id — the cell slot is `cell-<id>`, and it is what is remembered. */
    id: string;
    /** Header text (translated by the caller). */
    label: string;
    /** Shipped width, px. */
    width?: number;
    min?: number;
    max?: number;
    /** May the person hide it (and therefore move it)? Default true. */
    hideable?: boolean;
    /** May the person drag its edge? Default true. */
    resizable?: boolean;
    /** Does a header click sort by it? Default false. */
    sortable?: boolean;
    /** The first direction a click sorts in. Default 'asc'. */
    sortDir?: 'asc' | 'desc';
    /** What the column sorts by when the TABLE sorts (uncontrolled). Default:
     *  `format(row)`, else `row[id]`. Numbers sort as numbers, strings in the
     *  viewer's collation with digits read as numbers, empty values last. */
    sortValue?: (row: Row) => string | number | boolean | null | undefined;
    /** The cell's text when no `cell-<id>` slot is given. Default `row[id]`. */
    format?: (row: Row) => string | number | null | undefined;
    /** Hover text for the cell. Default: the text itself when it may be cut. */
    title?: (row: Row) => string | undefined;
    align?: 'left' | 'right' | 'center';
    /** Extra class on the header cell and every body cell of the column. */
    class?: string;
    /** Draw the header label? The explorer's star column draws none. */
    headerLabel?: boolean;
    /** The column that says WHICH ROW this is: pinned first, frozen left, never
     *  hidden or moved. Default: the first column. */
    lead?: boolean;
}

export declare const DataTable: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;

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

/** Result of reading one stored name. */
export declare interface DecodedName {
    /** The plaintext, when there is one. */
    name: string | null;
    /**
     * 'enc'        decrypted.
     * 'plain'      never encrypted — `name` is the stored name itself.
     * 'unreadable' looked like ours and did not decrypt: a long name whose
     *              sidecar is missing or does not match, a name moved into this
     *              folder without being re-encrypted for it, or damage.
     * 'sidecar'    bookkeeping; hide it.
     */
    state: 'enc' | 'plain' | 'unreadable' | 'sidecar';
}

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

/**
 * Decrypt a folder file as a stream, whichever version it is. A 0x01 file is
 * one AES-GCM message, so it is gathered (it is at most 200 MB) and opened in
 * one piece; a 0x02 file streams. A stream without the magic is passed
 * through as it is when `passPlain` (a file written in the clear over DAV),
 * and refused otherwise.
 */
export declare function decryptFolderFileStream(fmk: CryptoKey, previous: CryptoKey | null | undefined, ct: ReadableStream<Uint8Array>, opts?: {
    passPlain?: boolean;
    onPlain?: () => void;
}): ReadableStream<Uint8Array>;

/** The body (everything after the prefix) → the plaintext, checked end to end. */
export declare function decryptFxeBody(key: FxeKey, body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;

/**
 * Read one stored name found in the folder with id `parentId`.
 *
 * `readSidecar` fetches a sibling sidecar's content by its stored name; it is
 * only called for a long name. Returning null means "no such file".
 */
export declare function decryptStoredName(key: E2eNameKey, stored: string, parentId: Uint8Array, readSidecar?: (sidecarName: string) => Promise<string | null>): Promise<DecodedName>;

/** The product's own name, used until (and unless) an operator renames it. */
export declare const DEFAULT_BRAND_NAME = "filex";

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

/** The face a screen starts on when the plugin named none. */
export declare const DEFAULT_SIGN_FONT: SignFontKey;

export declare const DEFAULT_THEME_ID = "default";

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

/**
 * What an UNTOUCHED folder opens as — the person's default, else the
 * instance's, field by field. `undefined` fields mean "filex's built-in
 * default", which the caller owns (the explorer's host may pass its own
 * `config.viewMode`).
 *
 * ⚠ Sort is resolved as a PAIR: a person who chose "Size" and an operator
 * who chose "Modified ↓" must not produce "Size ↓".
 */
export declare function defaultFolderView(): {
    v?: ViewMode_2;
    k?: SortKey;
    d?: SortDir;
};

/** The worker URL for a pdf.js version when the host names none. */
export declare function defaultPdfWorkerUrl(version: string): string;

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

/**
 * Layers 2-3: the administrator's order over the host's. A STABLE sort, so
 * storages with no position, and storages that share one, keep the host's
 * relative order.
 */
export declare function defaultStorageOrder<T extends OrderableStorage>(storages: readonly T[]): T[];

/**
 * Define a box without placing it: a name, a type, whose it is — and a
 * sensible rectangle it will WEAR once somebody drops it on a page, so
 * placing is one click rather than a drawing exercise.
 */
export declare function defineField(list: PdfField[], type: PdfFieldType, opts?: {
    label?: string;
    assignee?: string;
    required?: boolean;
}): PdfField;

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

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

export declare const DENSITY_KEY = "filex.density";

/**
 * 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_17, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
pick: (path: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_17> & 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 (or, in a file pick, the file). */
    path: string;
    /** What to show — the entry'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 -
     *  or, `'vault'`, a folder the vault rule closes (vaultBlocked). */
    blocked: 'self' | 'descendant' | 'vault' | null;
    /** wiring:e2 vault — the folder is a vault (docs/E2E-VAULT-FORMAT.md). */
    vault?: boolean;
    /**
     * Folders are walked into; a file (offered only when the picker is asked
     * for one — an app plugin's `file-chooser`) is the answer itself.
     */
    kind: 'dir' | 'file';
}

/**
 * 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[], opts?: {
    files?: boolean;
}): DestinationRow[];

/**
 * Forget the account this module was reading for — sign-out. The next
 * `attachViewPrefsStore` reads the next person's document from scratch, and
 * nothing of the previous person's arrangement is left on screen for them.
 */
export declare function detachViewPrefsStore(): void;

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

/**
 * What this device is called in the person's list: "Chrome · Android",
 * "Safari · iPhone" - names, so the same in every language. The person sees it
 * beside a Remove button, so it only has to tell their own devices apart.
 */
export declare function deviceLabel(ua: string): string;

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

/** The digest's own event: it is what tells the held ones, so it is never held
 *  itself, and the settings pane offers it no "urgent" switch. */
export declare const DIGEST_EVENT = "notification.digest";

/** The folder id a folder's stored name carries, or null (a plaintext name). */
export declare function dirIdOf(stored: string): Uint8Array | null;

/**
 * The direction an element is actually laid out in: its nearest explicit
 * `dir="ltr|rtl"`. `dir="auto"` (user text isolated with `<bdi>`-like
 * behaviour) is skipped — it says nothing about the layout around it.
 */
export declare function dirOfElement(el: Element | null | undefined): TextDirection;

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

/**
 * downscaleImageToDataURL renders `file` into a square-cropped, downscaled
 * JPEG data URI no larger than `maxBytes`.
 *
 * Square-cropped on purpose: the strip draws circles, and a portrait squeezed
 * into a circle looks like a mistake. We take the centre square, which is where
 * a face is in practically every photo anyone picks as an avatar.
 */
export declare function downscaleImageToDataURL(file: File, { maxPx, maxBytes }: DownscaleOptions): Promise<string>;

export declare interface DownscaleOptions {
    /** Longest edge of the result, in pixels. */
    maxPx: number;
    /** Hard ceiling for the encoded data URI. Quality is stepped down until the
     *  result fits — a picture that arrives slightly softer beats one rejected. */
    maxBytes: number;
}

export declare const DRAFT_FOLDER_GONE = "FOLDER_GONE";

/** Refusal codes the server answers a draft request with (handlers/drafts.go). */
export declare const DRAFT_LIMIT = "DRAFT_LIMIT";

export declare const DRAFT_TARGET_TAKEN = "TARGET_TAKEN";

/** One draft, as the server answers it. */
export declare interface DraftDto {
    key: string;
    /** The file's name — the name it is meant to have. */
    name: string;
    /** Where the draft's bytes are (adapter-qualified): what an editor opens. */
    path: string;
    storage: string;
    /** Where it is meant to go, adapter-qualified: the folder, and the file. */
    target_dir: string;
    target: string;
    /** The New-document type it was made as (`txt`, `docx`, …). */
    type: string;
    size: number;
    mime?: string;
    created_at: string;
    modified_at?: string;
}

/** The limit a DRAFT_LIMIT refusal names, when it names one. */
export declare function draftLimitOf(err: unknown): number | null;

export declare interface DraftList {
    drafts: DraftDto[];
    count: number;
    limit: number;
}

/** What `save` came to. */
export declare type DraftSaveOutcome = {
    saved: true;
    path: string;
    name: string;
    targetDir: string;
}
/** Something already has the draft's name there. Nothing moved; the person
*  is asked, and `save(key, suggested)` saves under the free name. */
| {
    saved: false;
    taken: true;
    name: string;
    suggested: string;
    targetDir: string;
};

/**
 * Dragging files OUT of filex — onto the desktop, into another app.
 *
 * There are exactly two ways a page can hand real files to the operating
 * system, and filex uses both because neither one alone covers the ask:
 *
 * 1. **`DownloadURL`** (any Chromium browser, so the web explorer AND the
 *    desktop app get it for free). One `dataTransfer.setData('DownloadURL',
 *    'mime:name:url')` and the browser downloads that URL into wherever the
 *    drop landed. Costs nothing until the drop happens — but Chromium carries
 *    exactly ONE such entry, so it is a single-file gesture, and the URL is
 *    fetched by the browser's own download stack, which sends cookies but no
 *    Authorization header (see `canDownloadUrlDrag`).
 *
 * 2. **A native OS drag** (`webContents.startDrag`, desktop app only). Takes a
 *    list of real paths, so folders and multi-selections drop as separate real
 *    files — the WinRAR gesture. The catch is in the word *real*: the shell
 *    copies the bytes at DROP time, from a path, so the file has to be on this
 *    computer BEFORE the drag starts. There is no lazy/virtual-file API to
 *    borrow (that is a Win32 `IDataObject` affair Chromium does not expose).
 *
 * ⚠ The native drag REPLACES the HTML5 drag — `startDrag` requires
 * `preventDefault()` on `dragstart`, and after that the app's own drop targets
 * see an OS file drag instead of `application/x-brf-files`. Dropping a row on a
 * folder inside filex would then UPLOAD the temp copy back to the server: a
 * round trip of the same bytes, a copy instead of a move, and the original left
 * behind. That is what `beginNativeDrag` is for — the payload is remembered on
 * this side, and every drop target asks `internalDragItems(ev)` rather than
 * reading the dataTransfer directly. An OS drag we started is still an internal
 * drag when it lands inside our own window.
 *
 * Because the bytes must exist first, the shell is asked to prepare them on
 * `mousedown` — before the gesture becomes a drag — and the native path is only
 * taken when it answered "ready". Anything else keeps the ordinary HTML5 drag,
 * so an internal move never waits on a download it does not need.
 */
declare interface DragItem {
    path: string;
    basename: string;
    type: 'file' | 'dir';
}

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

/** Why one file is not sent. `too_many` carries how many the submission could take. */
declare type DropRefusal = {
    code: 'ext';
    name: string;
} | {
    code: 'too_large';
    name: string;
    mb: number;
} | {
    code: 'too_many';
    count: number;
};

/**
 * A drag released over GAP `gap` — the gap BEFORE row `gap` among the rows on
 * screen, the dragged row still counted (`0` = above the first, `n` = below
 * the last). ⚠ Its own two gaps are not a drop: releasing there leaves the
 * order as it was, and `null` says so, so nothing is written for a drag that
 * went nowhere.
 */
export declare function dropStorageAt(ordered: readonly OrderableStorage[], key: string, gap: number): string[] | null;

export declare const E2E_DEFAULT_ITERATIONS = 600000;

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

/** Folder file header version of a STREAM body. */
export declare const E2E_FILE_VERSION_STREAM = 2;

export declare const E2E_MAGIC = "filexe2e";

export declare const E2E_MARKER_NAME = ".filex-e2e.json";

/** Marker schema version written for a folder WITHOUT encrypted names. v1 still reads. */
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;

/** Chunk size writers use: 2^20 = 1 MiB of plaintext per chunk. */
export declare const E2E_STREAM_CHUNK_LOG2 = 20;

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

/**
 * wiring:e2 policy — may this account start encrypting at a path
 * (`POST /api/files/e2e/allowed`): `allowed`; `request` — the tenant's policy
 * wants an administrator's approval first; `denied`.
 */
export declare type E2eAnswer = 'allowed' | 'request' | 'denied';

/**
 * An existing folder being encrypted in place (marker v3, feature `conv`):
 * some of its files may still be plaintext. The folder is an encrypted folder
 * to the server from the moment this key file lands (the transfer guard, the
 * thumbnailer and the indexer treat it so), and while `pending` the server
 * lets a write replace a plaintext file with its ciphertext without keeping
 * the plaintext as a version. Removed when every file carries the magic.
 */
declare interface E2eConvSlot {
    pending: true;
    /** ISO time the conversion started. */
    started?: string;
    /** What to remove when it finishes (the owner's choice in the dialog,
     *  kept here so a resumed run honours it): versions, trash entries. */
    cleanup?: {
        versions: boolean;
        trash: boolean;
    };
}

/** How the person proves they may change the password. */
export declare type E2eCredential = {
    password: string;
} | {
    recoveryKey: string;
};

/** 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;
    /** v3 + req ['vault']: the vault (level 3). */
    vault?: E2eVaultSlot;
    /** v3 only: features a client must understand to open this folder. */
    req?: string[];
    /** v3 + req 'rekey': a re-key in progress. */
    rekey?: E2eRekeySlot;
    /** v3 + req 'conv': an in-place conversion in progress. */
    conv?: E2eConvSlot;
    /** v3 + req 'names': the encrypted-names slot. */
    names?: E2eNamesSlot;
    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;
}

/** A folder's name key, ready to use. */
export declare interface E2eNameKey {
    siv: SivKey;
    /** Shortening threshold this folder was created with. */
    long: number;
    /** The encrypted root's own folder id (from the marker). */
    rootId: Uint8Array;
}

export declare type E2eNameResolver = (wire: string, root: string) => {
    name: string;
    path: string;
} | null;

/** The plaintext of an item inside an encrypted folder, from a reader's
 *  explorer that has the folder unlocked; null when it does not. */
declare type E2eNameResolver_2 = (wire: string, root: string) => {
    name: string;
    path: string;
} | null;

/**
 * Encrypted-names slot (marker v3, feature `names`). Nothing in it is secret:
 * the key is sealed under the FMK, and the rest is the recipe.
 */
declare interface E2eNamesSlot {
    /** E2E_NAMES_ALG — AES-SIV (RFC 5297) with AES-256. */
    alg: string;
    /** E2E_NAMES_ENC — base64url, no padding. */
    enc: string;
    /** Encoded names longer than this are shortened to `<hash>.fxl` + sidecar. */
    long: number;
    /** base64: 12B IV || AES-GCM(FMK, 64-byte name key). */
    key: string;
    /**
     * base64url of the encrypted root's own 16-byte folder id: the associated
     * data of every name directly inside the root (lib/e2enames → "Folder
     * ids"). Not secret; random, minted with the name key.
     */
    root_id: string;
    /**
     * A switch from plaintext names to encrypted names started and has not
     * finished: some entries may still carry their plaintext name. The client
     * offers to resume; the rename pass is idempotent, so resuming is simply
     * running it again. Absent on a folder created with encrypted names.
     */
    pending?: boolean;
}

/** 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_45, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
submit: (payload: {
mode: "recovery" | "escrow";
value: string;
}) => any;
close: () => any;
}, string, PublicProps, Readonly<__VLS_Props_45> & Readonly<{
onSubmit?: ((payload: {
mode: "recovery" | "escrow";
value: string;
}) => any) | undefined;
onClose?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/**
 * A re-key in progress (marker v3, feature `rekey`): the folder has a NEW
 * folder master key, and some files still have their DEK wrapped under the
 * previous one. `from` is that previous key, sealed under the new one, so any
 * way into the folder also reaches the files not re-wrapped yet — and resuming
 * the re-wrap needs nothing but an unlock. Removed when the last file is done.
 */
declare interface E2eRekeySlot {
    /** base64: 12B IV || AES-GCM(new FMK, previous FMK raw 32B). */
    from: string;
    pending: true;
}

export declare interface E2eRequestDto {
    id: number;
    /** `<storage>://<rel>` - the folder the approval is for: to encrypt where it
     *  is (`folder`), or to make a new encrypted folder in (`new_folder`). A single
     *  file's request is kept under the folder its `.fxe` lands in (a file
     *  approval is that folder's). */
    path: string;
    storage: string;
    kind: E2eRequestKind;
    /** The requester's own words. */
    reason: string;
    status: 'pending' | 'approved' | 'rejected' | 'expired' | 'used';
    /** Who asked, named as the account was when it asked. */
    requester: string;
    requester_id: number;
    decider?: string;
    decided_at?: string | null;
    /** The approver's note, or why it was rejected. */
    decision_note?: string;
    expires_at: string;
    used_at?: string | null;
    created_at: string;
    tenant_id?: number | null;
}

/** An encryption request as the server answers it (backend E2ERequestWire). */
/** wiring:e2 policy - what an encryption request (and the question
 *  `POST /api/files/e2e/allowed`) is about (backend internal/e2epolicy, operator
 *  decision 2026-10-03: separate kinds, an approval opens only what was asked):
 *  `folder` - encrypt this folder where it is; `new_folder` - make one new
 *  encrypted folder directly inside this folder; `file` - encrypt this file. */
export declare type E2eRequestKind = 'folder' | 'new_folder' | 'file';

/**
 * wiring:e2 - the encrypted folder this pane's listing is inside, '' for none
 * (or when the host drives the rows: the host knows its own). The details
 * panel asks it so its "Create link" follows the Share row (lib/e2eLinks).
 */
declare function e2eRoot(): string;

/**
 * The vault block of a level-3 key file (docs/E2E-VAULT-FORMAT.md → "The key
 * file"). Fixed when the vault is made; nothing rewrites it.
 */
declare interface E2eVaultSlot {
    /** Format version of packs and index: 1. */
    v: number;
    /** 16 random bytes, base64url without padding (22 characters). */
    id: string;
    /** The pack size as a power of two: writers make 22 (4 MiB) or 24 (16 MiB). */
    pack: number;
}

/** `capabilities.edit_kinds` (backend editkind.Kinds). */
export declare interface EditKinds {
    /** Extensions the document server opens and edits. */
    office: string[];
    /** Extensions the built-in editor opens and save-text saves. */
    text: string[];
    /** Whole file names (lower case) that are text by name — `makefile`, `.gitignore`. */
    text_names: string[];
    /** Media types that make a file whose name says nothing text: `text/`… */
    text_mime_prefixes: string[];
    /** …and these exactly. */
    text_mimes: string[];
}

/** Has the server said how files are edited yet? */
export declare function editKindsKnown(): boolean;

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

/**
 * The id the CHILDREN of a folder are encrypted under: the one its stored
 * name carries, or — for a folder whose name was never encrypted — the id it
 * WILL carry (deriveDirId over its plaintext name), so its contents can be
 * encrypted before it is renamed and read in the meantime.
 */
export declare function effectiveDirId(key: E2eNameKey, parentId: Uint8Array, stored: string): Promise<Uint8Array>;

export declare function emptyCols<Id extends string = string>(): ColsState<Id>;

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

export declare const EncryptedFolderModal: DefineComponent<__VLS_Props_43, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
submit: (payload: {
name: string;
password: string;
level: ChoosableLevel;
/** `existing` only: remove the versions / trash entries filex holds. */
cleanup?: {
versions: boolean;
trash: boolean;
};
/** wiring:e2 vault — level 'vault' only: the pack size, log2 (22 or 24). */
packLog2?: number;
}) => any;
close: () => any;
}, string, PublicProps, Readonly<__VLS_Props_43> & Readonly<{
onSubmit?: ((payload: {
name: string;
password: string;
level: ChoosableLevel;
/** `existing` only: remove the versions / trash entries filex holds. */
cleanup?: {
versions: boolean;
trash: boolean;
};
/** wiring:e2 vault — level 'vault' only: the pack size, log2 (22 or 24). */
packLog2?: number;
}) => any) | undefined;
onClose?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface EncryptedName {
    /** What the server stores as the entry's name. */
    stored: string;
    /** The encoded ciphertext S (without a folder's `.D`). */
    encoded: string;
    /** For a folder: its id (kept, or derived). */
    dirId?: Uint8Array;
    /** Present only for a long name: the sidecar to write next to it. */
    sidecar?: {
        name: string;
        content: string;
    };
}

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

/**
 * Encrypt a file for an encrypted folder as a 0x02 STREAM file: a fresh DEK
 * wrapped under the folder key exactly as 0x01 wraps it, then the body.
 * `plainSize` must be exact — the stream errors when the source disagrees.
 */
export declare function encryptFolderFileStream(fmk: CryptoKey, plainSize: number, src: ReadableStream<Uint8Array>, opts?: FolderFileEncryptOptions): Promise<{
    stream: ReadableStream<Uint8Array>;
    size: number;
}>;

/**
 * Encrypt a plaintext name for the folder with id `parentId`. For a folder
 * pass `dirId` — its existing id when it is renamed or moved, or the derived
 * one when a plaintext-named folder gets its first encrypted name (never a
 * new one: its children are sealed under it) — or `isDir` alone for a NEW
 * folder, which gets a random id. Throws on a name `namePlainProblem` rejects.
 */
export declare function encryptName(key: E2eNameKey, plain: string, parentId: Uint8Array, opts?: {
    isDir?: boolean;
    dirId?: Uint8Array;
}): Promise<EncryptedName>;

/**
 * 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;
    shareCreate: string | null;
    shareList: string | null;
    shareDelete: string | null;
    limits: string | null;
    capabilities: string | null;
    /** The signed-in account (`/api/auth/me`): its role and permissions. */
    me: string | null;
    archiveList: string | null;
    archiveExtract: string | null;
    archiveCreate: 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;
    trashPurge: string | null;
    trashPurgeBatch: string | null;
    trashEmpty: string | null;
    versionPurge: string | null;
    e2eEscrowChallenge: string | null;
    e2eEscrowUsed: string | null;
    e2eCleanup: string | null;
    e2eAllowed: string | null;
    e2eRequests: string | null;
    pluginActions: string | null;
    pluginActionRun: string | null;
    pluginView: string | null;
    pluginViewEvent: string | null;
    /** `?plugin=<name>&q=` — the people-picker's user lookup (M2). */
    pluginUsers: string | null;
    /** v4 — an app's own interface: its module and its saves. */
    pluginUICall: string | null;
    pluginUISave: string | null;
    /** 0.54 - what an interface reads of the file it was opened with (`{plugin}`/`{view}`). */
    pluginUIRead: string | null;
    /** 0.52.0 - what an app reads about its own license (`{plugin}`), fx.license.get(). */
    pluginLicense: string | null;
    /** `POST` cancel of a queued/running ops row — `{id}` placeholder. */
    opsCancel: string | null;
}

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

/**
 * Fetch one added language's strings (`GET /api/public/ui-locales/{code}`).
 * Resolves true when a table is in hand. Idempotent: concurrent askers share
 * one request, and a language already loaded costs nothing.
 *
 * ⚠ A failure leaves the language listed with an EMPTY table (English shows)
 * rather than retrying on every repaint — a pack removed between the list and
 * this request answers 404, and hammering the server over it helps nobody.
 */
export declare function ensureLocaleStrings(code: string | undefined): Promise<boolean>;

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

/** Does this entry hold the page being looked at? */
export declare function entryIsCurrent(entry: MegaMenuEntry): boolean;

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

/**
 * `capabilities.event_off[event]` (backend capabilities_rules.go, #211 audit
 * B16): a notification event that cannot happen on this instance - what it
 * waits for, whether THIS caller could switch that on, and the sentence that
 * says so, in the reader's language. An event absent from the map can happen.
 */
export declare interface EventOff {
    /** `antivirus` | `escrow` | `app_plugins` | `e2e_approval`. */
    reason: string;
    /** The caller could switch it on: greyed with `text` for them, not offered
     *  to anybody else (lib/serviceGate `gateOnService`). */
    fixable: boolean;
    text: string;
}

/**
 * The event name as an i18n key SEGMENT.
 *
 * vue-i18n reads `.` as a path separator, so the event name cannot be a key on
 * its own: `webhooks.events.file.uploaded` would look for a nested `file`
 * object. The dots become underscores instead.
 */
export declare function eventSlug(event: string): string;

/**
 * The "⋯" rows whose control the explorer ALSO keeps on screen at every width:
 * the view switcher (list / grid / gallery) and the ⓘ at the end of the
 * breadcrumb row, and the panel toggle at the start of the top bar. An avatar
 * menu that repeated them would be two controls for one job — the owner's rule
 * (*"aynı işlevi yapan iki buton olmaması lazım"*), which the web page applied
 * first (Explore.vue ROWS_WITH_ANOTHER_DOOR) and the explorer applies to its own
 * avatar (FileExplorer `config.account`).
 *
 * ⚠ `inspector` only while the ⓘ is drawn — `config.showInfoPanel !== false`.
 */
export declare const EXPLORER_DRAWN_ROWS: readonly string[];

/** The explorer's table metrics — a tick column, the 28px ⋮, Name opening at
 *  `NAME_AUTO` — handed to `ColumnStore.layout` by the list view. */
export declare const EXPLORER_METRICS: {
    readonly gap: 8;
    readonly padding: 24;
    readonly check: 28;
    readonly menu: 28;
    readonly leadAuto: 220;
};

/**
 * The prefix on an explorer row's key inside the account menu, so an explorer
 * row named `settings` one day cannot silently take over the host's own row.
 */
export declare const EXPLORER_ROW_PREFIX = "fe:";

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/begin`, 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;
    /** @deprecated Ignored. The presigned S3 upload these named was removed
     *  from the server in 0.54.0; every upload goes through `uploadBegin`. */
    uploadInit?: string;
    /** @deprecated Ignored, as `uploadInit`. */
    uploadFinalize?: string;
    /** @deprecated Ignored, as `uploadInit`. */
    uploadAbort?: string;
    shareCreate?: string;
    shareList?: string;
    /** DELETE template; `{uuid}` placeholder is replaced at call time. */
    shareDelete?: string;
    limits?: string;
    capabilities?: string;
    /**
     * `/api/auth/me` — the explorer reads the account's permissions from it
     * when the host passes none (`permissions` below), so every surface
     * (the web app, the desktop app, work and fishapp embeds) hides the same
     * actions without each host wiring it.
     */
    me?: string;
    archiveList?: string;
    archiveExtract?: string;
    archiveCreate?: 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;
    /** Cancel a queued/running op — `{id}` placeholder (plugin jobs). */
    opsCancel?: string;
    /** App plugins: the actions list, the run template (`{plugin}`/`{action}`),
     *  the view template (`{plugin}`/`{view}`) and its `/event` sibling. */
    pluginActions?: string;
    pluginActionRun?: string;
    pluginView?: string;
    pluginViewEvent?: string;
    pluginUsers?: string;
    /** An app's own interface: its module (`{plugin}`/`{view}`) and its saves. */
    pluginUICall?: string;
    pluginUISave?: string;
    /** What an interface reads of its file, checked by the server (0.54). */
    pluginUIRead?: string;
    /** What an app reads about its own license (`{plugin}`), fx.license.get(). */
    pluginLicense?: string;
    /**
     * App plugins (file-menu rows drawn from WebAssembly plugins).
     *
     * Absent: follow the server — `capabilities.app_plugins.enabled`. `false`
     * switches the feature off for this instance whatever the server says, and
     * the explorer then makes no plugin request at all. `true` asks even when
     * the capabilities answer is missing (a host that knows its backend).
     */
    plugins?: boolean;
    /**
     * v4 — the signed-in person's display name, as an app's own interface may
     * know it (`session.user.name`; never an e-mail or a token). Absent: the
     * interface is told nothing about who is looking.
     */
    userName?: string;
    /**
     * Where this host serves the SPA, for an app plugin's `page` view
     * (`${pluginPageBase}apps/{plugin}/{view}?path=…`, lib/pluginPage).
     *
     * ⚠ A mount BASE, not the site root: the same bundle is served from
     * `/admin/` and `/drive/`, and only those prefixes fall back to index.html
     * for an `apps/…` address, so a bare `/apps/…` is a 404 on the server. The
     * host passes the prefix it was itself served from.
     *
     * Absent: a `page` action falls back to the modal — the same conversation
     * in a dialog. A degraded frame, never a missing feature.
     */
    pluginPageBase?: string;
    /**
     * How this host opens a plugin page. Return `true` when the host handled
     * it; anything else lets the explorer open a browser tab itself.
     *
     * ⚠ The hook exists for shells that have no tabs to open: the desktop app
     * wants its own window (and a `window.open` there lands in the system
     * browser with no session), an embed inside another product may want a
     * panel. The RULE — which actions open a page, and what the address is —
     * stays in the package for all of them (lib/pluginPage).
     */
    openPluginPage?: (target: {
        plugin: string;
        view: string;
        path?: string;
        /** The address the explorer would open, already built from `pluginPageBase`. */
        url: string;
    }) => boolean | void;
    /**
     * 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;
    /** Delete one trash entry for good — `DELETE`, `{id}` in the template
     *  (default `/api/admin/trash/{id}`); `?queued=1` makes it a job of the
     *  operations queue. Only an operator is let through. */
    trashPurge?: string;
    /** Delete several trash entries for good in one request — `POST
     *  {node_ids}` (default `/api/admin/trash/purge`), answered
     *  `{done, failed, reason_code, summary}`; `?queued=1` makes it jobs of the
     *  operations queue. Only an operator is let through. */
    trashPurgeBatch?: string;
    /** "Empty trash" (default `/api/admin/trash/empty`): POST starts it, GET
     *  reports it, and `<this>/preview` is the dry run whose count the
     *  confirmation names. Only an operator is let through. */
    trashEmpty?: string;
    /** Delete one version for good — `DELETE`, `{id}` in the template (default
     *  `/api/admin/versions/{id}`): its row and its stored bytes. Only an
     *  operator is let through. */
    versionPurge?: string;
    /** E2E escrow proof-of-possession — `POST { path } → { id, challenge }`. */
    e2eEscrowChallenge?: string;
    /** E2E escrow use report — `POST { path, id, nonce }`. */
    e2eEscrowUsed?: string;
    /**
     * @deprecated Ignored since 0.54: the server records an encrypted folder's
     * (or file's) password change itself, from the key file it sees rewritten,
     * and the explorer no longer announces it.
     */
    e2ePasswordChanged?: string;
    /** wiring:e2 convert — drop the plaintext filex holds after a folder is encrypted in place. */
    e2eCleanup?: string;
    /** wiring:e2 policy — `POST { items: [{ path }] } → { encrypt: ['allowed' | 'request' | 'denied', …] }`:
     *  may this account start encrypting at each path (default `/api/files/e2e/allowed`). */
    e2eAllowed?: string;
    /** wiring:e2 policy — `POST { path, kind, reason }`: ask an administrator to
     *  allow one encryption (default `/api/files/e2e/requests`). */
    e2eRequests?: 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;
    /**
     * Say a refused change as a toast inside the explorer. Default `true`.
     *
     * A change the server refuses — a rename, a move or a copy (drag, paste,
     * "Move to…"), a duplicate, a delete, a new folder, a permanent delete — is
     * said in a toast AND emitted as `error` (`{ message, context: { op } }`).
     * A host that already answers `error` with its own message sets `false`, and
     * the explorer leaves the saying to it: no toast (the lock sentence of a 423
     * included), the event still fires. A refusal whose dialog is still open is
     * shown in that dialog either way. Honoured the same in every surface.
     */
    refusalToasts?: boolean;
    /**
     * paylas:m1 — show the navigation panel's **My shares** row: the public
     * links THIS person handed out, directly under its mirror "Shared with me".
     *
     * Default: OFF, and it is the only row in that group whose default is off
     * for a reason that has nothing to do with taste. Every other entry either
     * opens a listing this component owns (Home, Recent, Starred, Trash, a tag,
     * a storage) or a panel it draws itself ("How to connect", "API keys") —
     * this one opens a page of the HOST. The explorer can announce the intent
     * (`open-my-shares`) and nothing more; a host that does not listen is left
     * with a row that draws, takes a click and does nothing at all. Off by
     * default is therefore the honest default: `<filex-explorer>` on
     * work.example.com, in the fishapp and on fm.example.com has no such page, and a dead
     * row is worse than a missing one.
     *
     * ⚠ Opting in is a promise, not a preference: set it to `true` only if you
     * handle `@open-my-shares`. The SPA does (`web/src/views/Explore.vue` pushes
     * its `my-shares` route), which is why it is the one host that asks for it.
     * Only the Vue component emits it: `<filex-explorer>` and the React
     * `<FileManager>` do not forward `open-my-shares`, so there it cannot be
     * handled and the flag must stay off.
     *
     * ⚠ ANDed with `callerKind`, never ORed: an app token is not a person and
     * has shared nothing, so the row goes with its mirror even for a host that
     * asked for it. See `callerKind`.
     */
    mySharesVisible?: boolean;
    /**
     * #162 - the host draws the **store screen** (the catalog of the trusted
     * stores an administrator turned on, where a person asks for an app) as a
     * page of its own, and handles `@open-app-store`: the SPA's `app-store`
     * route, the desktop app's store window.
     *
     * ⚠ Saying yes does not draw the row. The navigation panel's "Apps → App
     * store" row is drawn when the host can open the screen AND the server shows
     * it to this person (`GET /api/app-store` answers `visible`: the
     * administrator's setting for their tenant, their role and groups) AND the
     * caller is a person, not an app token - one rule, here in the explorer, for
     * every host (lib/appStoreRow). A host decides only whether it has the page.
     *
     * Default: OFF, for the reason `mySharesVisible` is off: a host that does not
     * listen would be left with a row that leads nowhere. `<filex-explorer>`
     * forwards `open-app-store` (the desktop app listens to it).
     */
    appStorePage?: boolean;
    /**
     * The host draws an app plugin's `home` view as a page of ITS OWN, in the
     * same tab (the SPA's `app-home` route), and handles `@open-app-home`.
     *
     * ⚠⚠ The owner, 2026-09-21: the Signatures screen opened as a dialog over
     * the file list, and it should be "its own page" — the way My shares is,
     * with its sections in a menu, the Back button working, and a
     * notification landing on the right section. The explorer cannot give a
     * host a page; it can only say which one was asked for, so the navigation
     * panel's "Apps" row emits `open-app-home` when this is on.
     *
     * Default: OFF, for the reason `mySharesVisible` is off — only the Vue
     * component emits the event, and a host that does not listen would be
     * left with a row that does nothing. Off, an "Apps" row keeps opening the
     * view in a dialog, which is a smaller frame but a working one.
     */
    appHomePage?: 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;
    /**
     * 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;
    /**
     * The signed-in account's effective permissions (filex backend
     * `internal/perm` — "files.delete", "share.links", …), as the host read
     * them from `/api/auth/me`. The explorer hides the actions the account may
     * not take — the same ones the server would refuse with 403
     * `permission_denied` — whether the host passes the list or not.
     *
     * Absent: the explorer reads `/api/auth/me` itself, through the same
     * `apiBase` as every other call, so every host hides the same actions
     * (0.49.0). Only when that answer is unusable too — the endpoint is off, the
     * request fails, or it carries no permissions — does every action stay and
     * the server decide. The fetched answer never narrows an administrator.
     *
     * Passed: this list wins and nothing is fetched. A rule that differs from
     * folder to folder is `permissionsByFolder`'s, asked of the server per path.
     */
    permissions?: string[];
    /**
     * The permissions whose answer differs from folder to folder (filex
     * `/api/auth/me` → `permissions_by_folder`): a role that allows Delete only
     * in Scratch, or denies it only in Finance. The explorer asks the server
     * about the selected paths (`?action=allowed`) before offering these, so
     * Delete shows in Scratch and not elsewhere. Ignored without `permissions`
     * (the explorer then uses the list it read from `/api/auth/me` itself).
     */
    permissionsByFolder?: string[];
    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;
        /**
         * #57 — the administrator's position for this storage (the server's
         * `sort_order`, set on the admin Storages page; 1 = first). Null or absent
         * = not placed: listed after the placed ones, in the order given here. The
         * navigation panel and Home draw the storages in the person's own order
         * when they have one, else in this one (`lib/storageOrder`).
         */
        sortOrder?: number | null;
        /**
         * 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. For a person without a quota the
         * storage line under the navigation sums these (lib/storageLine), and a
         * storage left without one is measured by the explorer itself.
         *
         * ⚠ 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;
        /**
         * `usedBytes` counts only part of the storage: its catalog does not cover
         * all of it yet (the server's `coverage` beside the figure —
         * lib/catalogCoverage). The card then draws it as a lower bound. Absent:
         * the explorer uses what the last listing said about the storage.
         */
        usedPartial?: boolean;
    }>;
    /**
     * 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;
            /** Files written into the drop so far, inside folders too. */
            files?: number;
        }) => void) => void;
        /** Stops filling in a drop that has landed (the explorer offers "Stop"
         *  while it runs); the shell reports it as `error: 'cancelled'`. */
        stop?: () => void | Promise<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;
    };
    /**
     * #47 — the host holds several accounts at once (the desktop app's rail),
     * and ⌘K's "Everywhere" group should search all of them.
     *
     * The explorer never talks to another account's server itself: it has no
     * credential for one, and it must not be handed any. Every call that reaches
     * another account goes through this hook, and the host answers it with the
     * credential it already keeps for that account. Hits come back tagged with
     * the account they belong to (`GlobalSearchHit.account`) and the palette
     * draws one group per account under a badge, this mount's own first.
     *
     * Absent — the web admin, every embed, a desktop with one account — and the
     * palette is exactly what it was: this account's hits, no badges.
     */
    accountSearch?: AccountSearchHook;
    /**
     * The notification bell in the explorer's OWN header — the web app's bell,
     * drawn by the explorer for a host that cannot fill the `header-actions`
     * slot (2026-09-27, the desktop app: it raised an OS notification for every
     * row and had nowhere inside the window to read one, mark it read or follow
     * it to what it was about).
     *
     * ⚠⚠ The SAME components the web draws (NotificationBell, NotificationRow,
     * NotificationsPanel, UnreadBadge) over the SAME feed logic
     * (useNotificationFeed) — the explorer only supplies the transport (its own
     * credential against `/api/notifications`) and the landing: a click opens
     * the folder in THIS explorer with the row selected, the Trash view, an
     * app's home view, or a share page in a new window.
     *
     * ⚠ Why a config field and not the slot: a `<filex-explorer>` host cannot
     * fill any slot (see `brand`). A Vue host that fills `header-actions` with
     * its own bell (the web app) must NOT set this as well — it would draw two.
     *
     * Absent (the web app, every embed): nothing new renders and nothing is
     * fetched.
     */
    notifications?: {
        /**
         * Ask the server every 15 s (NOTIFY_POLL_MS). Default true. `false` for a
         * host that already polls the bell and hands the count over through
         * `onUnread` — the desktop app's main process does, for its OS
         * notifications and dock badge, and a second loop would be a second
         * request every 15 s for a number it already has.
         */
        poll?: boolean;
        /** Register for counts the host learned itself. Called once, at mount;
         *  the host keeps ONE subscriber and overwrites it on remount. */
        onUnread?: (cb: (count: number) => void) => void;
        /** Told after this explorer marked a row (or all rows) read — so a host
         *  badge (the dock, the tray) does not wait for its next poll. */
        onRead?: () => void;
        /** The administrators' console for notifications — drawn as the bell's
         *  smaller second door only when given (so only to an administrator). */
        manage?: {
            href: string;
            open: () => void;
        };
    };
    /**
     * The account menu (the avatar) in the explorer's OWN header, for the same
     * kind of host as `notifications` — the same component the web draws
     * (AccountMenu), with the host's rows.
     *
     * ⚠ The explorer's "⋯" settings rows FOLD INTO it, exactly as they do on
     * the web (owner, 2026-09-13: *"`...` bölgesini admin dropdown'ının içine
     * alacağız"* — one menu in that corner, not two). The order is
     * lib/accountMenu's: `actions`, then the explorer's rows minus `omit`, then
     * `tail`. A row of the explorer's runs through the explorer's own handler.
     */
    account?: {
        /**
         * The person's own settings — the admin app's user settings dialog
         * (UserSettingsDialog), opened IN this explorer from a "User settings" row
         * the explorer puts first. It talks to the account's own endpoints with
         * this explorer's credential. Rows only some surfaces have (language,
         * start page, one click or two, desktop-app downloads, browser
         * notifications) are not drawn here. With it, the "⋯" rows whose control
         * it carries (theme, compact view, time zone) leave the menu, as they do
         * on the web.
         */
        settings?: boolean;
        /** Rows above the explorer's — this account's own doors (the admin
         *  console). A function so the host can decide per person (an
         *  administrator gets one more). */
        actions: AccountAction[] | ((person: AccountPerson | null) => AccountAction[]);
        /**
         * Rows below the explorer's — where the web page puts Sign out.
         *
         * ⚠ The desktop app gives NONE, and that is a decision, not an omission
         * (owner, 2026-09-27): the avatar holds the person's INTERFACE settings,
         * and signing an account out of the app is an APP setting, done in the
         * app's own Settings → Accounts. There is deliberately no separate
         * `signOut` switch: the row exists only if a host puts it here, so
         * "no sign out" is simply no tail.
         */
        tail?: AccountAction[] | ((person: AccountPerson | null) => AccountAction[]);
        /** The explorer's "⋯" rows this host already has another door for. */
        omit?: string[];
        /** One of the HOST's rows was chosen. */
        select: (key: string, person: AccountPerson | null) => void;
        /** Who is signed in. Absent → the explorer asks `/api/auth/me` with its
         *  own credential (the one request it already makes for the account's
         *  time zone). */
        person?: AccountPerson | null;
    };
}

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

/**
 * The explorer's own path form for a destination — what goes in the address
 * bar hash, e.g. `qldemo/Documents` (and just `qldemo` for a storage root).
 *
 * ⚠ Measured, not assumed: the explorer writes `#<storage>/<relative path>`
 * while its rows carry `data-fe-path="<storage>://<relative path>"`. Two
 * different shapes of the same location, and mixing them up produces a hash
 * the explorer reads as a folder literally named `qldemo:`.
 */
export declare function explorerHashPath(dest: NotificationDestination): string;

/** A row the explorer's toolbar announces for its "⋯" (Toolbar `fe:header-menu`). */
export declare interface ExplorerMenuRow {
    key: string;
    label: string;
    divider?: boolean;
    disabled?: boolean;
    icon?: string;
}

/**
 * The explorer's own ADDRESS for a destination — what its `load()` and its
 * `initialPath` take: `qldemo://Documents`, `qldemo://` for a storage root,
 * `.trash` for the Trash view, `''` for anything the explorer does not open.
 *
 * ⚠ The qualified shape (`<storage>://<path>`), NOT the hash shape above. The
 * explorer navigating itself — its own bell, a desktop OS notification handed
 * to it — has no address bar to go through, so it takes the form its rows and
 * its listings speak.
 */
export declare function explorerPathOf(dest: NotificationDestination): string;

/**
 * The explorer row a menu key names, or `null` when the key is the host's.
 */
export declare function explorerRowKey(key: string): string | null;

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

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

/** What the caller should do about a failure it just had. */
export declare type FailureVerdict = 'folded' | 'say';

/** How many of the person's own rows the bell holds. It shows 15; the rest is
 *  headroom for the browser-notification diff, which reads the same list. */
export declare const FEED_LIMIT = 50;

/** Is this field required right now — declared, or by a `required_when` that holds? */
export declare function fieldRequired(f: PluginField, values: Record<string, unknown>): boolean;

export declare type FileApi = ReturnType<typeof useFileApi>;

export declare interface FileChooserNodeProps {
    kind?: 'file' | 'dir' | string;
    /** Adapter-qualified path. */
    value?: string;
}

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

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;
    /**
     * The folder's size leaves something out: the catalog does not cover all of
     * it yet (a lazily cataloged folder, or any folder while its storage's first
     * sync runs). `size` is then a lower bound, or unknown when 0. Draw it with
     * useLocale `formatNodeSize`, never `formatSize` (docs/LAZY-CATALOGUE.md).
     */
    size_partial?: boolean;
    /** Unix ms (backend "last_modified"). */
    last_modified?: number;
    /** MIME. */
    mime_type?: string;
    /** Optional thumbnail URL (backend may inline). */
    thumb_url?: string | null;
    /**
     * Why the file has no thumbnail, when the reason is the file's own (0.50):
     * damaged, encrypted (an office password, a zip's, or filex's end-to-end
     * encryption) or over a size limit. The views mark the type icon with it
     * (lib/thumbNote, ThumbTile). Absent when there is a picture, while one is
     * being drawn, and for a failure that may pass (it is drawn again).
     */
    thumb_note?: ThumbNote | null;
    /**
     * A folder's newest files (0.50): up to three of the files directly in it,
     * newest first by the later of when each came in and when it last changed,
     * each with its stamped thumbnail URL when one is ready (else the views
     * draw its type icon). Absent for a folder with no files of its own, and
     * while folder previews are off (docs/thumbnails.md → Folder previews).
     */
    preview?: {
        name: string;
        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;
    e2e_vault?: boolean;
    e2e_root?: string;
    e2e_stored?: string;
    e2e_name_state?: 'enc' | 'plain' | 'unreadable' | 'locked';
    e2e_display_dir?: string;
    vault_root?: string;
    fxe_name?: string;
    /** An app plugin holds this file read-only (docs/APP-PLUGINS-API.md →
     *  "File locks"). `perm` already arrives capped at `viewer` for everyone,
     *  administrators included — the flag is what the badge and the details
     *  panel say out loud, and what turns the server's 423 into words. */
    locked?: boolean;
    lock?: AppLock;
    /** The state keys apps keep on this file, `<plugin>:<key>`. Read by the
     *  menu's state-aware rows (`applies.state` / `no_state`). */
    app_state?: string[];
    /** Issue #34 — this row is a symlink the SERVER WILL NOT FOLLOW. A link
     *  whose target is inside the storage root IS followed and arrives as that
     *  target (a linked directory is a `dir` and opens normally), so this flag
     *  always means "cannot be opened", never merely "is a link".
     *
     *  ⚠ Additive, and `type` stays the closed `'file' | 'dir'` union it has
     *  always been: widening it would be a breaking change for every embedder
     *  of `@brftech/filex`, so the backend reports such a row as a file and
     *  flags it here (`handlers/manager.go`). A client that does not know the
     *  flag renders exactly the row it rendered before — which is precisely the
     *  0-byte-file-that-will-not-open the issue was filed about, and why
     *  `lib/symlink` exists. */
    symlink?: boolean;
    /** Why it will not open — `outside_root` | `broken` | `unresolved`.
     *
     *  Every listing carries it when the reason is known: one read from the
     *  driver says what the driver says now, one answered by the catalogue says
     *  what the sync recorded (migration 00098, filex 0.54). ⚠ It can still be
     *  absent - a row catalogued before 0.54 until the next sync of its folder,
     *  a driver that gives no reason - so read it through
     *  `lib/symlink.linkStateOf`, which answers `'unknown'` for that case (and
     *  for a state a newer server invents) instead of dropping the row back into
     *  silence. */
    link_state?: string;
    /** Issue #104 - an entry the STORAGE COULD NOT ANSWER FOR: the sync asked
     *  whether it still exists and got neither "yes" nor "not found". It is
     *  listed so it does not just vanish, and nothing can be done with it, or
     *  with anything inside it: the server refuses every operation with 409
     *  `ENTRY_UNAVAILABLE`. Read through `lib/unavailable`. */
    unavailable?: boolean;
    /** What the storage answered (its own words, usually English). */
    unavailable_reason?: string;
    /** Generic — any additional fields the backend wants to inline. */
    [k: string]: unknown;
}

export declare const FilePane: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

/**
 * How a surface node reaches a file the page exposes (`files[].ref`):
 * the host resolves the ref to a URL the browser may load directly (the
 * PIN cookie rides along on the same origin). Absent outside public pages.
 */
declare type FileRefResolver = (ref: string) => {
    url: string;
    name?: string;
    mime?: string;
} | null;

/**
 * Fill mode's `data.values[id]`: the signer's own fields that hold a value.
 *
 * ⚠ `font` and `rule` travel WITH the value. The plugin stamps the PDF from
 * this array alone — it never sees the screen — so a signature typed in
 * Caveat that arrives as a bare string is stamped in whatever the plugin
 * happens to default to, which is how a signed document comes back in a
 * face the signer never chose.
 */
export declare function fillValues(fields: PdfField[], signer: string | undefined): {
    fields: PdfFillEntry[];
};

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

/**
 * v3 §3.2 — the width to draw a page at so the WHOLE page fits the box.
 *
 * ⚠⚠ The complaint that started the round: a signature page you had to
 * scroll in two directions. The document was fitted to the column's WIDTH, so
 * a portrait page in a landscape window ran off the bottom — the boxes were
 * then found by hunting rather than by reading. Fitting means whichever of
 * the two constraints binds.
 *
 * `gap` is the breathing room around the page (the scroll box's padding),
 * taken off the HEIGHT: a page that touches the toolbar reads as clipped.
 * A box with no height yet (before layout) falls back to the width, which is
 * the old behaviour and is corrected on the first resize observation.
 */
export declare function fitPageWidth(box: {
    width: number;
    height: number;
}, page: {
    width: number;
    height: number;
}, gap?: number): number;

/** Send anything still waiting, now (a window closing, a test). */
export declare function flushPrefs(): Promise<void>;

/**
 * HOW MANY FOLDERS WE REMEMBER, and how the number was chosen.
 *
 * ⚠⚠ Without a cap this is one entry per folder ever changed, forever, in a
 * database row replicated into every backup; the endpoint refuses a document
 * over 128 KB, so left uncapped saving would eventually stop working,
 * silently, for the people who use the product most.
 *
 * 300 is derived: a view-only entry serialises to ~110 bytes and one that also
 * carries its own columns to ~260, so even 300 of the heavier kind is ~78 KB —
 * inside the endpoint's limit with room for longer paths. And the map only
 * gains an entry when somebody CHANGES a folder (walking through one writes
 * nothing), so in real use the cap is a ceiling on the pathological case.
 */
export declare const FOLDER_CAP = 300;

/**
 * THE EXPLORER'S COLUMN STORE for one folder — the generic store
 * (`lib/tableColumns`) over the explorer's columns, backed by this folder's
 * memory with the default beneath it.
 *
 * ⚠ `''` is not a folder: it is the person's DEFAULT layout. A listing reaches
 * it only when its host switched the per-folder memory off
 * (`config.rememberFolderView: false`), and for such a host "one arrangement
 * everywhere" is exactly what it asked for.
 *
 * ⚠ "Reset columns" in a folder means "follow my default here again": the
 * store writes an empty state and `rememberFolder` turns that into dropping
 * the folder's `c`, not into pinning the SHIPPED layout on this folder.
 */
export declare function folderColumnStore(keyOf: () => string): ColumnStore<ColumnId>;

export declare interface FolderFileEncryptOptions {
    /** Chunk size, log2. Tests only — writers use E2E_STREAM_CHUNK_LOG2. */
    chunkLog2?: number;
    onProgress?: (bytes: number) => void;
}

/** True when this folder has a memory the PERSON made (not a seed). */
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,
 * so it is not a stable address; every protocol accepts a storage's immutable
 * `uid` as the first path segment for exactly that reason. This takes the
 * storage REF the host gave us — name or uid — and the moment
 * `config.storages[].uid` is populated, keys become rename-proof. Until then
 * renaming a storage loses its folders' memory (they fall back to the
 * default — a mild, self-healing loss).
 *
 * 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;

/**
 * ⚠ DEPRECATED — always true. The per-folder memory used to be an opt-in,
 * off by default, and that default was half of the leak the owner reported
 * (see the header). Kept exported so an embedder that read it keeps
 * compiling; a host that genuinely wants no per-folder memory passes
 * `config.rememberFolderView: false` to the explorer, which is the host's
 * decision rather than a hidden switch in a person's settings.
 */
export declare function folderMemoryEnabled(): boolean;

/** One folder's remembered setup. Short keys: 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;
    /** this folder's own columns — absent = the default's */
    c?: ColsState<ColumnId>;
    /** last used, epoch SECONDS — the LRU clock. */
    t: number;
}

/** This folder's OWN memory (or its seed), or null — never a default. */
export declare function folderPrefs(key: string): Omit<FolderPrefs, 't'> | null;

/** A person's default folder view. */
export declare interface FolderViewDefault {
    v?: ViewMode_2;
    k?: SortKey;
    d?: SortDir;
    /** default columns (widths, hidden, order) */
    c?: ColsState<ColumnId>;
}

/** Case- and accent-folded, so "İstanbul" answers to "ist" and "Ödev" to "od".
 *  ⚠ `toLowerCase()` alone maps `İ` to `i` + a combining dot, which then
 *  matches nothing the user typed; stripping the marks is what makes the two
 *  sides comparable.
 *  ⚠ And the four Latin i's are one letter (internal/namefold): `ı` has no
 *  mark to strip, so without the last step "ışık" did not answer to "IŞIK".
 *
 *  ⚠ This is NOT how a file name is searched - the search keeps accents
 *  ("musteri" does not find "müşteri"). It is the LABEL rule: the admin
 *  panel's search (lib/panelSearch) folds its own page and setting labels
 *  with it, the same rule the server's panel search applies (namefold.Loose).
 *  A file name the person types into "Filter in this folder" is matched by the
 *  server (`lib/nameFilter`); this rule answers only a name the server must
 *  not see (decrypted in this tab) - see `nameMatches`. */
export declare function foldText(s: string): string;

/**
 * Re-read the choices when the account's answer lands (another device changed
 * them). Call once from a component's setup; returns the unsubscribe.
 */
export declare function followOpenWithChoices(): () => void;

/**
 * ⚠⚠ TEXT FILEX DID NOT WRITE, made readable in `code`'s direction.
 *
 * A sentence the SERVER composed (`server.*`, reaching the browser as the
 * `message` of a refusal), an installed app's own words, a notification built
 * from what happened — none of it passes through `useLocale().t` or the admin
 * panel's post-translation hook, so none of it was isolated. It is exactly
 * the text that carries machine runs: a path, a URL, a command, a token
 * syntax.
 *
 * Measured in the Arabic admin panel (v0.43.0 pack round, the local Arabic
 * test pack): `server.token.scope_unknown` names the syntax
 * `root:<storage>://<folder>`, and the closing `>` — a neutral between the Latin run and the Arabic after
 * it — resolved to the paragraph's direction, jumped to the FAR LEFT of the
 * run and mirrored into `<`, so the line read `…<root:<storage>://<folder`.
 * The same sentence drawn from the catalogue was correct, which is what makes
 * this read as a broken pack rather than as a missing call.
 *
 * ⚠ A pack cannot fix it: bidi control characters are forbidden in a
 * translation and the pack's own validator refuses them (`BIDI`). It is the
 * render site's job, and this is the render site's one function.
 */
export declare function foreignText(code: string | null | undefined, text: string): string;

/** Forget every folder's own view. */
export declare function forgetAllFolders(): void;

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

/**
 * The session ended: this browser forgets everything it cached ABOUT THE
 * PERSON.
 *
 * Owner, 2026-09-21: *"oturum kapanınca temizlersek localstorage'ı tamamız ya
 * o kısımda"* — once somebody has left, their preferences are not something
 * this machine should go on holding.
 *
 * ⚠⚠ It is an "and", not an "instead of". Clearing only covers the moments
 * the app KNOWS about; it cannot cover a cookie that quietly expired, a tab
 * closed without signing out, or a browser whose owner never signs out at all.
 * `hasSession()` is what covers those, by making the keys unreadable rather
 * than absent. Drop either one and the sign-in page goes back to wearing the
 * last person who used this browser.
 *
 * ⚠ The in-memory document goes too, and the queued PUT with it. Leaving
 * `remote` behind would keep `hasOwnChoice()` answering for somebody who has
 * gone; leaving `pending` behind would fire a write with their values a moment
 * after their cookie stopped existing.
 */
export declare function forgetPersonalPrefs(): 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. Nothing in the product needs it today — the share
 * message used it to copy the server's e-mail (`humanSize()`, base 1024), and
 * the server writes sizes by THESE rules now (backend/internal/srvtext
 * `Bytes`), so the message, the mail and the listing say one thing. If a
 * mirror is ever needed again it is an argument here, not a fifth copy.
 */
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;

/**
 * An instant as a person reads it — THE date format of the product: the
 * explorer's, "Sep 21, 2026, 2:50 PM" / "21 Eyl 2026, 14:50", in the viewer's
 * language and on the viewer's chosen clock. `time: true` adds the clock.
 *
 * ⚠⚠ One definition for every surface (QA, 2026-09-21): the explorer printed
 * "21 Eyl 2026, 14:50", the admin tables and the share dialog "21 Eyl 2026
 * 15:02" (a `dateStyle: 'medium'` pair and a `day: '2-digit', hour: '2-digit'`
 * set of their own), and English times read "2:50 PM" on one screen and
 * "02:51 PM" on the next. The admin panel's `formatDate`, `useLocale`'s
 * `formatDate` and the share lines all call this now; nothing else builds a
 * date formatter for a person to read (scripts/dup-scan.mjs, `datetime-format`).
 */
export declare function formatWhen(value: WhenInput, code: LocaleCode | string | undefined, opts?: {
    time?: boolean;
}, 
/** The explorer whose clock applies (EXPLORER_CLOCK); omitted = page-wide. */
owner?: symbol): string;

/**
 * The whole truth, for a tooltip behind a short date: full date, seconds, the
 * zone's name AND its IANA id — "whose 14:05 is this?" answered. The IANA id
 * rides along because half the world's zones display as "GMT+3".
 */
export declare function formatWhenFull(value: WhenInput, code: LocaleCode | string | undefined, owner?: symbol): string;

/** Every `form` node's fields in a surface, flat. */
export declare function formFields(nodes: SurfaceNode[] | undefined): PluginField[];

export declare interface FormNodeProps {
    fields: PluginField[];
    /** Initial values, keyed by field key. Field values are FLAT in `data.values`. */
    values?: Record<string, unknown>;
}

/**
 * pdfFieldsGeom — where a `pdf-fields` box is, as pure arithmetic.
 *
 * A field's place is stored as FRACTIONS of the page's rendered viewport
 * (0..1, origin top-left, CropBox and /Rotate already applied by pdf.js's
 * viewport), so it survives any zoom and any screen. Three conversions are
 * needed around that and they all live here, DOM-free:
 *
 *   fraction ↔ pixel   the drag on screen (a page drawn `size` CSS px wide)
 *   fraction ↔ PDF     the rectangle in PDF user space (points, origin
 *                      bottom-left of the UNROTATED page) that a stamping
 *                      plugin needs, for /Rotate 0, 90, 180 and 270
 *
 * The rotation maps are the ones pdf.js's `PageViewport` applies: 90 is the
 * page turned clockwise on screen, so the unrotated top-left corner lands at
 * the rendered top-right; 270 turns it counter-clockwise.
 */
/** A box as fractions of the rendered page (0..1, origin top-left). */
declare interface FracRect {
    x: number;
    y: number;
    w: number;
    h: number;
}

/** Fractions of the rendered page → PDF user-space rectangle (points, origin bottom-left, unrotated). */
export declare function fracToPdf(r: FracRect, page: PageBox): PdfRect;

export declare function fracToPixel(r: FracRect, size: {
    width: number;
    height: number;
}): PixelRect;

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;
}

/** How the person opens a `.fxe`. */
export declare type FxeCredential = {
    password: string;
} | {
    recoveryKey: string;
} | {
    escrowKey: CryptoKey;
};

export declare interface FxeHeader {
    salt: string;
    iter: number;
    verify: string;
    fmk: 'wrapped';
    fmk_pw: string;
    rk?: E2eRecoverySlot;
    esc?: E2eEscrowSlot;
    dek: string;
    name: string;
    chunk: number;
    nonce: string;
    size: number;
    req?: string[];
    /** Anything a newer filex wrote; kept on rewrite. */
    [k: string]: unknown;
}

/** What an unlock hands back: everything reading and naming the file needs. */
export declare interface FxeKey {
    header: FxeHeader;
    /** The file's own master key (what the slots wrap). */
    fmk: CryptoKey;
    /** The STREAM key. */
    dek: CryptoKey;
    /** The original name, NFC. */
    name: string;
}

declare type FxeUnlock = {
    key: FxeKey;
} | {
    error: 'wrong' | 'damaged';
};

/**
 * `available` — the service is configured and healthy.
 * `callerAdmin` — this caller could go and configure it.
 * `reason` — the sentence an administrator reads (what is missing, where to
 * fix it), already translated.
 */
export declare function gateOnService(available: boolean, callerAdmin: boolean, reason: string): ServiceGate;

/** 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.
 *
 * The share page's tokens follow, under the page's own selectors
 * (variables.css `.fe.fe-ppage` and its dark twins - the same specificity,
 * later in the document, so the theme's win): what the theme defines, else
 * its own tones (`publicPageTokens`).
 */
export declare function generateThemeCss(theme: ThemeDef): string;

/** What one table looks like right now. */
export declare interface GenericTableLayout<Id extends string = string> {
    /** The columns drawn after the lead, in the person's order. Never shortened
     *  for width — a table wider than its pane scrolls. */
    visible: Id[];
    /** Every drawn track's width in px, the lead's included. */
    widths: Record<Id, number>;
    /** The table's own width: every track, every gap, both paddings. */
    total: number;
    /** True while the widths are derived from the pane rather than stored. */
    auto: boolean;
}

export declare function getDensity(): Density;

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';
    /** Drive NAME the hit lives on (the server fills it; older ones did not). */
    storage?: string;
    /**
     * #47 — which signed-in account the hit came from. Never on the wire: the
     * explorer stamps it when the host searches several accounts
     * (`ExplorerConfig.accountSearch`). Absent = this mount's own account, with
     * no other account in play.
     */
    account?: SearchAccount;
    [k: string]: unknown;
}

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

declare function goUp(): void;

/** A single ACL grant row (RBAC permissions panel): to one person, or — with
 *  `kind: 'group'` — to a group, every member of which holds it. A group's
 *  grant has its own id space (change it with the *GroupPermission calls). */
declare interface Grant {
    id: number;
    storage_id: number;
    path_prefix: string;
    /** "user" or "group"; absent from servers older than groups (a person). */
    kind?: 'user' | 'group';
    user_id?: number;
    group_id?: number;
    group_name?: string;
    level: 'viewer' | 'editor' | 'owner';
    user_email?: string;
    user_display_name?: string;
    /** The person as every screen names them (server model.PersonLabel). */
    user_name?: string;
    inherited?: boolean;
}

declare interface Group {
    id: string;
    label?: string;
    items: any[];
}

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

/**
 * Hits → one group per account, in the order accounts first appear (the
 * explorer lists its own account first), each capped at `limit` on its own —
 * a busy account must not push a quieter one off the list.
 */
export declare function groupHitsByAccount(hits: GlobalSearchHit[], limit: number): HitGroup[];

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

/** A group the caller could share with (GET /api/files/permissions/groups). */
declare interface GroupSuggestion {
    id: number;
    name: string;
    description?: string;
}

/**
 * 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[];

/**
 * The name a password-carrying client signs in with, from the account's e-mail
 * and — on a multi-tenant server, for a tenant's account — its realm
 * (`/api/auth/me` → `realm`): `acme/alice@example.com`. A protocol that carries no
 * address a tenant could be told by needs the realm written in front
 * (docs/PROTOCOLS.md), and on the tenant's own address it names the same
 * tenant, so it is always correct to print it. No realm: the e-mail alone,
 * exactly as before.
 */
export declare function guideUser(email: string, realm?: string | null): string;

/** Is there anything in this value at all? `false` and `0` count as answers. */
export declare function hasAnswer(v: unknown): boolean;

/** The person has a ceiling: a positive quota the server did not call unlimited. */
export declare function hasCeiling(p: PersonUsage | null | undefined): boolean;

/** Is this a language the interface can actually be set to? (Reactive.) */
export declare function hasLocale(code: string | undefined | null): boolean;

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

/**
 * Is a person signed in here? The synchronous, first-paint answer.
 *
 * ⚠ `true` for a host that has not declared `sessionAware` — see that
 * option. "Nobody told us about sessions" means "this explorer is inside
 * something that already dealt with it", not "nobody is here".
 */
export declare function hasSession(): boolean;

/** Does this surface have a `steps` node — i.e. is it a step of a walk? */
export declare function hasSteps(nodes: SurfaceNode[] | undefined): boolean;

/** The keys a surface is currently NOT showing (across every form on it). */
export declare function hiddenKeys(nodes: SurfaceNode[] | undefined, values: Record<string, unknown>): string[];

/** What the explorer knows about drives when a hit does not say its own. */
export declare interface HitDriveContext {
    /** Drive names the host configured (`config.storages`). */
    configured: string[];
    /** The drive the explorer has open right now. */
    current: string;
}

/** One account's hits, in the server's order. `account` undefined = no rail. */
export declare interface HitGroup {
    account?: SearchAccount;
    hits: GlobalSearchHit[];
}

/**
 * The hit as a drag-out / download item (`name://rel`, its name, its kind) —
 * or null when there is nothing to address: no path, or no drive to put it on.
 * The same `{path, basename, type}` a listing row hands the drag-out hook.
 */
export declare function hitItem(hit: GlobalSearchHit, ctx: HitDriveContext): DragItem | null;

/**
 * Which drive a hit lives on: the name the server sent > `storage_name`
 * (older servers) > the only configured drive > the drive that is open.
 * A wrong last-resort guess lands on the listing's "folder not found" state,
 * which is a graceful dead end — not a request against the wrong file.
 */
export declare function hitStorageName(hit: GlobalSearchHit, ctx: HitDriveContext): string;

/**
 * Map one raw search hit onto the listing shape.
 *
 * ⚠ The drive comes from the HIT (`describeHits` puts it there), not from the
 * pane we happen to be standing in — a content search spans storages, so the
 * open drive is only the right answer by accident. `storageName` stays as the
 * fallback for a backend older than that field.
 *
 * (Moved here from FileExplorer's `advHitToNode` for #47, unchanged: the
 * palette's download and drag-out need the same row the advanced search draws.)
 */
export declare function hitToNode(h: GlobalSearchHit, storageName: string): FileNode;

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

/**
 * Read the account's preferences.
 *
 * Answers `null` when there is nothing to apply — no session, an older
 * server with no such route, a network that is not there. ⚠ `null` is not an
 * error: the mirror has already painted the window, and a preference is the
 * last thing that should put an error in front of a person.
 */
export declare function hydratePrefs(): Promise<UiPrefs | null>;

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

/**
 * Black or white on this colour, by luminance.
 *
 * ⚠ Not a constant. An operator who picks a pale accent gets white text on
 * pale yellow if the ink is hardcoded — which is what "unreadable button"
 * looks like to the person reporting it, and it is only ever seen on
 * somebody else's instance.
 */
export declare function inkOn(hex: string): string;

/** The x of a box's inline END edge — its right in LTR, its left in RTL. */
export declare function inlineEndX(r: {
    left: number;
    right: number;
}, dir: TextDirection): number;

/**
 * A horizontal arrow key as a step along the line: +1 = toward the inline END
 * (→ in LTR, ← in RTL), -1 = toward the start, 0 = not a horizontal arrow.
 * The key a person presses moves things the way the arrow on it points.
 */
export declare function inlineKeyStep(key: string, dir: TextDirection): -1 | 0 | 1;

/** +1 for the physical x axis in LTR, -1 in RTL: "toward the inline end". */
export declare function inlineSign(dir: TextDirection): 1 | -1;

/** The x of a box's inline START edge — its left in LTR, its right in RTL. */
export declare function inlineStartX(r: {
    left: number;
    right: number;
}, dir: TextDirection): number;

/**
 * The instance's default folder view — the OPERATOR's answer, set in the admin
 * settings (`ui.default_folder_view`) and handed to the client beside the
 * person's document. It carries no widths: a width is about a screen and the
 * operator does not know anybody's; which columns show is a fair instance-wide
 * call, so that part is here.
 */
export declare interface InstanceFolderDefault {
    v?: ViewMode_2;
    k?: SortKey;
    d?: SortDir;
    hidden?: ColumnId[];
}

/** The operator's default. Reactive. */
export declare function instanceFolderDefault(): InstanceFolderDefault;

/** Forget every cached answer — tests, and a host that just installed a plugin. */
export declare function invalidatePluginActions(): void;

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;

/** Is this the step's backward action? */
export declare function isBackAction(a: Pick<SurfaceAction, 'id'>): boolean;

export declare function isBuiltinLocale(code: string): code is LocaleCode;

/** Is this failure "the folder this draft is meant for is not there any more"? */
export declare function isDraftFolderGone(err: unknown): boolean;

/** Is this failure "you already keep as many drafts as this server allows"? */
export declare function isDraftLimit(err: unknown): 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;

/**
 * Fill mode: may `signer` act on this field? Their own, and any field that
 * was never assigned (a one-signer document rarely bothers with assignees).
 */
export declare function isFieldOf(field: Pick<PdfField, 'assignee'>, signer: string | undefined): boolean;

/** True for an entry drawn as a plain link rather than a panel. */
export declare function isLinkEntry(entry: MegaMenuEntry): boolean;

/**
 * Does this key END a list item in a chip-style field (the typed address or
 * tag becomes a chip)? `,` and each of its siblings above — the same set the
 * splitter uses, so a field that splits a paste and a field that commits on a
 * keypress agree about what a comma is.
 */
export declare function isListSeparatorKey(key: string): 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;

/**
 * Is there anywhere for a click on this row to GO?
 *
 * ⚠⚠ The answer used to be "yes, always": a row with no target took the
 * person to the notifications page, which is the page they were most likely
 * already looking at — a click that shuffles the view and answers nothing.
 * Worse, that page is admin-gated, so for everybody else the same click threw
 * away the folder they were standing in (the guard bounced them) and the row
 * was STILL not about anything. A row that cannot go anywhere now takes no
 * cursor, no hover and no click; reading it is the whole interaction.
 */
export declare function isNotificationClickable(target: NotificationTarget | null | undefined): boolean;

/** Does a file of this extension open in the document server? */
export declare function isOfficeExt(ext: string | null | undefined): boolean;

/** The handler is ONLYOFFICE's editor (not an app's interface, not filex's viewer). */
export declare function isOfficeHandler(h: Pick<OpenHandler, 'id'> | null | undefined): boolean;

export declare function isolateLtrRuns(text: string): string;

/** Is this a request the client can act on at all? */
export declare function isOpenRequest(v: unknown): v is SurfaceOpenRequest;

/** Does this action open its view as a full page rather than a dialog? */
export declare function isPagePlacement(placement: string | undefined | null): boolean;

/** Is this box on the page yet? Absent `placed` means yes. */
export declare function isPlaced(f: PdfField): boolean;

/**
 * A plain left click that the HOST should turn into an in-app navigation. A
 * click with a modifier (new tab, new window, download) or another button is
 * left to the browser, which is what makes the items real links.
 */
export declare function isPlainClick(ev: Pick<MouseEvent, 'button' | 'metaKey' | 'ctrlKey' | 'shiftKey' | 'altKey' | 'defaultPrevented'>): boolean;

/**
 * webdavMount — the forms of a filex WebDAV address, and the operating
 * systems' own commands that attach one as a drive.
 *
 * Two readers, one source:
 *  - the connection guide (`connectionGuides.ts`) PRINTS these for a person to
 *    copy;
 *  - the desktop app's "Mount as a drive" (`desktop/src/drive.ts`) RUNS them.
 * Written twice, the command the guide teaches and the one the button runs
 * would drift apart, and the person who copied the guide's version would hit
 * a failure the button never shows — or the other way round.
 *
 * ⚠ No imports, and none may be added. The desktop main process and its
 * `node --test` runner import this file by relative path (the way
 * `packages/core/src/lib/notificationTarget.ts` is imported), and plain node does not
 * resolve an extensionless specifier.
 */
/** 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;

/** Whether a menu key names a plugin action. */
export declare function isPluginActionKey(key: string): boolean;

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

export declare function isSignatureValue(v: unknown): v is SignatureValue;

/** Is this one of the five? (A value off the wire is not trusted.) */
export declare function isSignFontKey(v: unknown): v is SignFontKey;

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

export declare function isTagKind(v: unknown): v is TagKind;

/**
 * Is this file one the built-in editor opens and save-text saves? By its
 * name (extension, or a name that is text on its own), else by the server's
 * mime for its bytes — the two halves of save-text's own check.
 */
export declare function isTextEditable(file: {
    basename?: string | null;
    extension?: string | null;
    mime_type?: string | null;
} | null | undefined): boolean;

/** Is this media type text a person edits as text (a name that says nothing,
 *  `LICENSE`, #56)? */
export declare function isTextualMime(mime: string | null | undefined): boolean;

/** Is this an entry the storage could not answer for? */
export declare function isUnavailable(node: Pick<FileNode, 'unavailable'> | null | undefined): boolean;

/**
 * Is this row one no surface may try to open?
 *
 * ⚠⚠ THE DECISION, WRITTEN DOWN. An unfollowable link is refused by the
 * CLIENT, before any request, and the refusal is spoken (a toast carrying
 * `why`). The two alternatives were both live bugs:
 *
 *   • doing nothing is issue #34 itself — the row that "just does not open";
 *   • letting the request go is barely better, because the driver answers with
 *     a containment error that surfaces as a generic failure and reads like a
 *     server fault rather than a deliberate, configurable boundary.
 *
 * Refusing here costs nothing the person could have had: the server would
 * refuse it too, and only this side knows the sentence that says why and names
 * the setting that changes it.
 */
export declare function isUnopenableLink(node: Pick<FileNode, 'symlink' | 'link_state'> | null | undefined): 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;

/** What the server says about a failed app job (ops row `error_code`). */
export declare type JobErrorCode = 'timeout' | 'out_of_memory' | 'crashed' | 'app_removed' | 'action_removed' | 'engine_missing' | 'office_unconfigured' | 'cancelled' | 'app';

export declare function jobFailure(op: {
    error?: string | null;
    error_code?: string | null;
    error_engine?: string | null;
    error_text?: string | null;
}, fallback: string, t: T, opts?: {
    callerAdmin?: boolean;
}): SaidFailure;

export declare interface JobOpen {
    /** The app that ran the job - the screen named is one of ITS own. */
    plugin: string;
    open: SurfaceOpenRequest;
}

export declare function jobOpenOf(op: Pick<PendingOp, 'op_type' | 'status' | 'plugin' | 'open'>, opts?: {
    busy?: boolean;
}): JobOpen | null;

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

/** The key of the item spelled exactly `name`, when the server sent one. */
export declare function keyOfName(items: readonly TagItem[], name: string): string | undefined;

/**
 * The kind a request of this HTTP method counts as.
 *
 * ⚠ The method, not the URL. A read is the page keeping itself up to date and
 * can be folded; a write is something the person pressed and is waiting on.
 * The one rule both request layers apply, so the web app and an embedded
 * explorer cannot classify the same call differently.
 */
export declare function kindOfMethod(method: string | undefined): RequestKind;

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

export declare interface LayoutMetrics {
    /** Space between cells (`--fe-gap-sm`). */
    gap?: number;
    /** Row padding, both sides together (`--fe-gap` × 2). */
    padding?: number;
    /** The tick column's track, or 0 for a table with no tick. */
    check?: number;
    /** The trailing actions column's track (the explorer's ⋮ is 28). */
    menu?: number;
    /** What the lead opens at when nobody has sized anything. */
    leadAuto?: number;
}

/**
 * Why a link will not open.
 *
 * The first three are `storage.LinkOutsideRoot` / `LinkBroken` /
 * `LinkUnresolved`. `unknown` is ours: the row says it is a link and the
 * server did not say why — a row the sync has not given a reason yet (see the
 * note above), or a server newer than this client that named a state we have
 * never heard of. Both deserve the honest general sentence rather than
 * silence.
 */
export declare type LinkState = 'outside_root' | 'broken' | 'unresolved' | 'unknown';

/**
 * The state of a row the server will not follow, or `null` for every ordinary
 * row — including a link it DID follow, which arrives as its target and is not
 * a link as far as anyone using it is concerned.
 */
export declare function linkStateOf(node: Pick<FileNode, 'symlink' | 'link_state'> | null | undefined): LinkState | null;

/** The short word on the row, and the sentence behind it. */
export declare interface LinkWords {
    state: LinkState;
    /** The badge's visible text — two words at most; the row is narrow. */
    badge: string;
    /**
     * What it is, why it will not open, and who can change that — in a sentence,
     * because "Outside" on its own is a second riddle rather than an answer.
     */
    why: string;
}

/**
 * The words for a state.
 *
 * ⚠ BROKEN IS NOT OUTSIDE-OF-ROOT and must never read as if it were. Telling
 * somebody an administrator can allow a link whose target has been deleted
 * sends them to a settings screen that will not help, and leaves the real
 * repair — fix or remove the link on the server — unsaid.
 *
 * ⚠ Literal `t('…')` keys on purpose: `web/tests/i18n/coreKeysUsed.test.ts`
 * scans the source for them and skips anything computed, so a table built with
 * `t('symlink.badge.' + state)` would take these eight strings outside the only
 * check that notices a key nobody ever added to the catalogues.
 */
export declare function linkWords(state: LinkState | null, host: LinkWordsHost): LinkWords | null;

/** The one call a view makes: the words for this row, or `null`. */
export declare function linkWordsFor(node: Pick<FileNode, 'symlink' | 'link_state'> | null | undefined, host: LinkWordsHost): LinkWords | null;

/** What `linkWords` needs from the caller's locale. */
export declare interface LinkWordsHost {
    t: (key: string, vars?: Record<string, string | number>) => 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';

/**
 * A `list` node — drawn by the product's one table (DataTable).
 *
 * ⚠ Everything past `key`/`label`/`id`/`cells` is OPTIONAL and additive
 * (docs/APP-PLUGINS-API.md → `list`): a plugin written against the first
 * contract draws the same rows, now resizable, sortable and with columns a
 * person can hide and move.
 */
export declare interface ListNodeProps {
    columns: Array<{
        key: string;
        label: PluginText | string;
        /** Opening width in px (60–900). */
        width?: number;
        /** Default true — the node carries every row, so sorting is honest. */
        sortable?: boolean;
        align?: 'left' | 'right' | 'center';
        /** What the cells are: `date` (`YYYY-MM-DD`) or `datetime` (RFC 3339). The
         *  host prints them in the reader's language and clock and sorts by the
         *  value as sent (lib/surfaceCell). */
        format?: 'date' | 'datetime';
    }>;
    rows: Array<{
        id: string;
        cells: Record<string, PluginText | string>;
        actions?: ListRowAction[];
        /** Raw values to sort by, keyed like `cells`, where the cell is formatted
         *  for people (a localised date, "1.2 MB"). */
        sort?: Record<string, string | number>;
    }>;
    empty?: PluginText | string;
}

/** 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[];

export declare interface ListRowAction {
    id: string;
    label: PluginText | string;
    danger?: boolean;
}

declare function load(): Promise<void>;

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

/**
 * Ask the server which languages this instance offers.
 *
 * ⚠ It asks the BRANDING route, which is the one public answer about how
 * this instance presents itself — and the one the public shell already
 * fetches. ⚠ A failure is not an error: the two built-in languages are
 * already on the picker, and the list is then treated as KNOWN (a held
 * choice falls back) — waiting forever for an answer that will not come
 * would keep somebody's interface in a language nothing can serve.
 */
export declare function loadLocales(opts?: LoadLocalesOptions): Promise<PublicLocaleOption[]>;

declare interface LoadLocalesOptions {
    /** API origin; empty = same origin. */
    base?: string;
    fetchImpl?: typeof fetch;
    /** Per-call auth for a host that does not ride on cookies. */
    headers?: () => Promise<Record<string, string>> | Record<string, string>;
}

/**
 * The library, or `null` when it cannot be loaded (not installed, blocked).
 * The first caller's `workerUrl` wins; pdf.js holds one global worker path.
 */
export declare function loadPdfjs(workerUrl?: string | null): Promise<PdfjsLib | null>;

/**
 * Fetch the server's public sentences for the page's language, and again
 * whenever the language changes. A failed fetch leaves the table empty and
 * `ready` true: the page still opens (its controls carry no words of their
 * own), and nothing invents a sentence in the server's place.
 */
export declare function loadPublicText(opts: PublicTextOptions): PublicTextSource;

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

/**
 * A language code. `tr` and `en` are the two this package ships a catalogue
 * for; ANY other tag may arrive too — a language pack (an app whose manifest
 * carries `ui_locales`) adds languages at run time, see `lib/uiLocales`.
 * `(string & {})` keeps the two named ones in autocompletion without
 * pretending they are the only ones.
 */
export declare type LocaleCode = 'tr' | 'en' | (string & {});

/** `'rtl'` when the server says this language is written right to left. */
export declare function localeDir(code: string | null | undefined): TextDirection;

/** A language's own name for itself. */
export declare function localeLabel(code: string): string;

/**
 * The words a language has of its OWN — what `t()` reads first.
 *
 *   - a built-in (`en`, `tr`): its catalogue, with a pack that overlays it on
 *     top (the overlay IS that language's words);
 *   - a pack's language: the pack's strings and nothing else;
 *   - a language with no strings yet (not fetched, fetch failed, empty pack,
 *     or a code nothing offers): English, AS English — `lang` is `en`.
 *
 * ⚠⚠ Why not `localeTable`. That one merges English under the pack, so "the
 * table has `toast.restored_one`" is true for a Spanish pack that wrote only
 * `toast.restored` — the English singular was sitting underneath — and the
 * count of one printed "1 item restored" in the middle of a Spanish screen.
 * The plural rule has to know which forms the language itself wrote, and
 * fall back to English as a WHOLE (English's form, by English's rule) only
 * when the language wrote none.
 *
 * ⚠ The last case answers `lang: 'en'` on purpose: French puts 0 in `one`,
 * so reading English strings by French rules would print "0 item".
 *
 * Starts the fetch for a listed language whose strings are not in hand, the
 * same as `localeTable`.
 */
export declare function localeOwnTable(code: string | undefined): OwnLocaleTable;

/**
 * Has the server's list arrived? Until it has, a stored choice that LOOKS like
 * a language (`plausibleLocale`) is held rather than thrown away — the same
 * rule the palette follows for a custom theme whose list is still in flight
 * (`lib/themes` plausibleThemeId). Without it a person who picked a pack's
 * language opened every page in English: the stored `es` was judged against
 * a list that had not been fetched yet, refused, and never looked at again.
 */
export declare const localesKnown: Ref<boolean, boolean>;

/**
 * Just the strings a pack added for this language — no catalogue under them.
 *
 * ⚠ For a host with a catalogue of its own (the admin SPA's `web/src/locales`)
 * that merges the same table into ITS `t()`. Handing it `localeTable` would
 * fold this package's keys into the host's, which is two catalogues becoming
 * one by accident.
 */
export declare function localeStrings(code: string | undefined): Record<string, string>;

/** Bumped whenever the list or a table changes; `useLocale` and the pickers watch it. */
export declare const localesVersion: Ref<number, number>;

/**
 * One language's table with English merged underneath.
 *
 * Order, and why: English underneath as the last resort, then the built-in
 * catalogue when the language has one, then the pack's table on top. So a
 * pack that translates three strings gets three strings and an otherwise
 * English screen — never a page of raw keys — and a pack that overlays two
 * Turkish strings changes exactly two.
 *
 * ⚠ Not what `t()` reads any more — see `localeOwnTable`. In this merge a
 * key the pack never wrote and a key it did are indistinguishable, and the
 * plural rule needs to tell them apart.
 *
 * ⚠ Asking for a language whose strings have not been fetched STARTS the
 * fetch and answers English meanwhile; `localesVersion` moves when they land,
 * and every computed that read this re-reads it.
 */
export declare function localeTable(code: string | undefined): Record<string, string>;

export declare function localeTag(code: LocaleCode | string | undefined): string;

/** What this DEVICE last saw — read before the network, never trusted after it. */
export declare function localPref(key: LookKey): string;

/** Everything the mirror holds, for the boot that has no server answer yet. */
export declare function localPrefs(): UiPrefs;

/** The body of a `423 {"error": "locked", …}`. */
export declare interface LockedRefusal extends AppLock {
    /** The path the server refused — the file, or the folder above it. */
    path?: string;
    /** The server's sentence for the refusal, in the reader's language. */
    message?: string;
}

/**
 * A rejected request that was a LOCK, not a permission problem — `null` for
 * anything else, so a caller can keep its existing error path untouched.
 *
 * ⚠ The status alone is the test that matters (`useFileApi` puts the raw body
 * in `.detail` and never parses it). A body that is missing or unparseable
 * still produces a refusal, with an empty plugin name: "an app is holding
 * this file" beats "Error (423)" even when the server said no more than that.
 */
export declare function lockedRefusal(err: unknown): LockedRefusal | null;

/** The lock a listing row carries, or `null`. */
export declare function lockOf(node: Pick<FileNode, 'locked' | 'lock'> | null | undefined): AppLock | null;

/**
 * A lock's reason in the reader's language: the app's own words for it
 * (`reason_text`, a manifest message the server kept in every language the
 * app wrote), else the plain `reason`.
 *
 * ⚠ The reason used to be ONE string in the language of whoever took the
 * lock, so a German administrator read the Turkish requester's "imzalar
 * toplanıyor" (v0.43.0 wave 2).
 */
export declare function lockReasonText(lock: AppLock | null | undefined, locale: string | undefined): string;

/** " — until 3 Oct 2026", or `''` when the lock has no end. */
export declare function lockUntilText(until: string | null | undefined, host: LockWordsHost): string;

/**
 * One sentence for a lock: who holds it, why, until when — with every part
 * that is missing simply left out rather than printed as "undefined".
 */
export declare function lockWords(lock: AppLock | LockedRefusal | null, host: LockWordsHost): string;

/** What `lockWords` needs from the caller's locale. */
export declare interface LockWordsHost {
    t: (key: string, vars?: Record<string, string | number>) => string;
    /** The explorer's own date renderer, so a lock reads on the user's clock. */
    formatDate?: (ms: number | undefined | null, opts?: {
        time?: boolean;
    }) => string;
    /** The reader's language: which of the reason's languages to show. */
    locale?: string;
}

/** The sign-in page's ground and card. */
export declare const LOGIN_PAGE_TOKENS: readonly ["--fe-login-ground", "--fe-login-card"];

export declare const LogoMark: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, SVGSVGElement>;

/**
 * The keys with a first-paint mirror in `localStorage` — what the window is
 * painted with, nothing else.
 *
 * ⚠ `storageOrder` is one: the navigation panel draws the storages on the very
 * first frame, and without a mirror a person who reordered them would watch
 * the list jump from the host's order to theirs once the account answered. It
 * is also the ONLY place the order lives for an embed that never wires the
 * account document (`prefsConfigured()` false). The tour is not: it is a
 * one-way flag with a browser key of its own (`lib/tour`).
 */
export declare const LOOK_KEYS: readonly LookKey[];

/** The keys that paint the window — each has a first-paint mirror (below). */
export declare type LookKey = Exclude<PrefKey, 'tour' | 'appState' | 'appsSeen' | 'openWith'>;

/** Good enough for "this looks like an address" — the server validates. */
export declare function looksLikeEmail(s: string): boolean;

/**
 * True for text a person should not be shown as the sentence: a JSON body, a
 * status line, an environment variable, a Go error chain, a stack trace, a
 * file path on the server.
 *
 * ⚠ It guards words that came from somewhere we do not control — an app's
 * own error text above all. A real sentence ("Bu belge zaten imzalanmış")
 * passes; plumbing does not. It is deliberately greedy: a human sentence
 * mistaken for plumbing costs the person the app's wording (they still read
 * a sentence), plumbing mistaken for a sentence is the defect.
 */
export declare function looksTechnical(s: string): boolean;

/**
 * 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;
    e2e_vault_root?: string;
    files: FileNode[];
    /** `action=search` only: more rows matched than came back — the index
     *  filled its page, or the index-less fallback filled its window — so the
     *  list is not the whole answer. Absent on other actions and on servers
     *  older than the flag. */
    truncated?: boolean;
    /** Every storage the caller can open, with how much of it the catalog
     *  covers (`coverage`, absent when all of it — lib/catalogCoverage). Absent
     *  on servers older than the lazy catalog. */
    storage_info?: StorageInfo[];
}

/** `text` rendered as Markdown and sanitized; null when markdown-it is unavailable. */
export declare function markdownToSafeHtml(text: string): Promise<string | null>;

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

/** True when the folder's file and folder names are encrypted (feature `names`). */
export declare function markerHasNames(m: E2eMarker | null): boolean;

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

/**
 * Record that the tour has been offered: in this browser at once, and on the
 * account as soon as the account's document is known.
 *
 * ⚠⚠ Never written to the account BEFORE its document has arrived. `PUT
 * /api/me/prefs` replaces the whole document, and a write made from an empty
 * copy would erase the person's palette, density and language to record a
 * tour.
 */
export declare function markTourSeen(): void;

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

/** One row of `GET /api/files/quota/storages` (handlers.StorageUsageRow). */
export declare interface MeasuredDrive {
    name: string;
    used_bytes: number;
    file_count?: number;
    coverage?: CatalogCoverage | null;
}

export declare const MegaMenu: DefineComponent<__VLS_Props_13, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
navigate: (target: {
id: string;
href: string;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_13> & Readonly<{
onNavigate?: ((target: {
id: string;
href: string;
}) => any) | undefined;
}>, {
mode: "bar" | "list";
}, {}, {}, {}, string, ComponentProvideOptions, false, {
root: HTMLElement;
}, HTMLElement>;

/**
 * A top entry: either a panel of sections, or - with `href` and no sections -
 * a plain link (the dashboard).
 */
export declare interface MegaMenuEntry {
    id: string;
    label: string;
    sections?: MegaMenuSection[];
    href?: string;
    active?: boolean;
    icon?: Component;
}

/** One page of a section. */
export declare interface MegaMenuItem {
    /** Stable key and test hook (`nav-<id>`); the admin panel uses the route name. */
    id: string;
    label: string;
    /** The short line under the label. */
    hint?: string;
    /** Where the item goes. A real address, so a middle click opens a tab. */
    href: string;
    /** The page being looked at (or one of its own sub-pages). */
    active?: boolean;
    /** A glyph from the HOST's icon set, drawn as a component. */
    icon?: Component;
    /**
     * Or a glyph from the core icon library, by NAME (`lib/actionIcons`). Only
     * the name crosses this boundary - never markup - so the menu draws static
     * SVG this package wrote, whoever the host is.
     */
    iconName?: string;
}

/** A named group of pages inside an entry's panel (a column on a wide screen). */
export declare interface MegaMenuSection {
    id: string;
    label: string;
    items: MegaMenuItem[];
}

/**
 * A backing that lives in this component's memory only — for a table on a
 * surface with no account behind it (a public page), and for tests.
 */
export declare function memoryBacking<Id extends string = string>(initial?: ColsState<Id>): ColumnBacking<Id>;

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

/** Every key this module writes starts with this. */
export declare const MENU_ANSWERS_PREFIX = "filex.menuAnswers.v1|";

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

export declare function moveColumn(id: ColumnId, index: number): void;

/** One step left or right among the movable columns of the default layout. */
export declare function moveColumnBy(id: ColumnId, delta: -1 | 1): void;

/**
 * Move one storage `delta` rows (−1 = up, +1 = down). The whole new order, or
 * `null` when the move would go past either end — the menu greys the row out
 * for exactly that case, and a caller that asks anyway changes nothing.
 */
export declare function moveStorage(ordered: readonly OrderableStorage[], key: string, delta: number): string[] | null;

/** What Name opens at when nobody has sized anything — ~26 characters at
 *  13px/500, enough for `Quarterly Report Q2.pdf` to read whole. */
export declare const NAME_AUTO = 220;

/** How narrow a person may drag Name: the tile, its gap and ~11 characters. */
export declare const NAME_MIN = 120;

export declare interface NamePassIo {
    /** The raw listing of a folder (stored names, not decorated). */
    list(dirWire: string): Promise<NamePassRow[]>;
    /** A sibling sidecar's content, or null when there is none. */
    readSidecar(dirWire: string, sidecarName: string): Promise<string | null>;
    writeSidecar(dirWire: string, sidecarName: string, content: string): Promise<void>;
    /** Rename `row` (in `dirWire`) to the stored name `to`. */
    rename(dirWire: string, row: NamePassRow, to: string): Promise<void>;
    /** Asked between entries: stop as soon as this says so. */
    stopped(): boolean;
}

export declare interface NamePassProgress {
    /** Entries renamed so far. */
    renamed: number;
    /** Entries that could not be renamed (no permission, a name a disk cannot
     *  hold, a name that cannot be read at all). */
    failed: number;
    /** Entries found needing a name. */
    seen: number;
    /** Of `renamed`, entries that had been moved without being re-sealed. */
    repaired?: number;
}

export declare interface NamePassRow {
    path: string;
    basename: string;
    type: 'file' | 'dir';
}

/**
 * The rules a plaintext name must meet before it is encrypted. They are the
 * rules a name must meet on a local disk, because `filex decrypt` writes
 * these names to one: nothing that is a path separator, a control
 * character, `.`/`..`, or longer than 255 UTF-8 bytes.
 */
export declare function namePlainProblem(name: string): NameProblem | null;

/** Why a plaintext name cannot be encrypted, or null when it can. */
export declare type NameProblem = 'empty' | 'dot' | 'slash' | 'control' | 'too_long';

/**
 * A row of the "Apps" section — an app plugin's `home` view, already read in
 * the viewer's language by the host (docs/APP-PLUGINS-API.md → Placements).
 */
export declare interface NavApp {
    /** `<plugin>/<view>` — what `open-app` carries back. */
    key: string;
    label: string;
    /** A manifest icon name; drawn when `lib/actionIcons` has it, else the plugin glyph. */
    icon?: string;
}

/**
 * Whether the line has to ask the server for drive sizes: there is no
 * ceiling, and the host left at least one of the panel's drives unsized (the
 * desktop app hands over names only) — or listed none at all.
 */
export declare function needsMeasuredDrives(p: PersonUsage | null | undefined, panel: readonly PanelDrive[]): boolean;

/** The request never got an answer (offline, DNS, CORS, a dropped socket). */
export declare function networkFailure(locale: string | undefined, cause?: unknown): RequestFailure;

/**
 * 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. The key the create call sends,
     *  unless `key` says otherwise. */
    ext: string;
    /** What the create call names when it is not `ext`: an app's row
     *  (`app:<plugin>:<ext>`), whose extension a built-in kind may share. */
    key?: string;
    /** Coarse family, used for the picker's section headings (`app`: a row an
     *  installed app adds, `new_documents`). */
    group: 'document' | 'text' | 'diagram' | 'app';
    mime: string;
    /** External service the editor for this type needs; absent = built-in;
     *  `app` = an app's interface (listed only while it runs). */
    requires?: 'onlyoffice' | 'drawio' | 'app';
    /** An app's row: the app, the `viewer` view that opens the new file, and
     *  the app's own words for it. */
    app?: {
        plugin: string;
        view: string;
        label: Record<string, string>;
    };
    /**
     * Must the file carry this extension? (#56) `true` for the containers — an
     * office document or a diagram, which its editor finds by extension; `false`
     * for text, which may be named anything (`LICENSE`, `test.conf`). ABSENT on
     * a server from before #56, which appends the extension to every type —
     * lib/newDocName `extLocked` reads that as `true`.
     */
    ext_required?: boolean;
}

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

/** Answer to `?action=newfile` — where the new document actually landed. */
/**
 * A New document name, checked by the server without anything being written
 * (`?action=newfile` with `dry_run`, #211 audit B18): the name the create
 * would write, whether something already holds it, and the first free
 * `name (n).ext` beside it - the server's own existence check and numbering,
 * not a lower-cased copy in the browser.
 */
declare interface NewFileCheck {
    dry_run: boolean;
    path: string;
    name: string;
    taken: boolean;
    /** `NAME_TAKEN` when taken. */
    code?: string;
    /** The first free name beside a taken one; absent when there is none. */
    suggested?: string;
}

declare interface NewFileResponse {
    /** Adapter-qualified path, ready to hand to the viewer. */
    path: string;
    /** Made from an app's row (`new_documents`): the view that opens it. Set
     *  by the New document dialog, not by the server. */
    app?: {
        plugin: string;
        view: string;
    };
    /** Final basename, which may have gained the extension server-side. */
    name: string;
    /** The TYPE the bytes were made from (a `newdoc_types` key) — not the
     *  extension of `name`, which since #56 may have none (`LICENSE`). The
     *  explorer opens the new file as this type. */
    ext: string;
    size: number;
    mime: string;
    /** Drafts (issue #71): set when the document was made as a DRAFT — then
     *  `path` is the draft's, in the person's drafts area, and nothing is at
     *  the destination yet (lib/drafts). */
    draft?: DraftDto;
}

/** 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_52, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
host: string;
port: number;
enabled: boolean;
path?: string;
readOnly: boolean;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_52> & 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;
}

declare type NodeLike = (AppliesNodeLike & {
    type?: string;
}) | null | undefined;

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

/** `#abc` → `#aabbcc`; anything that is not a hex colour → ''. */
export declare function normalizeAccent(raw: string | undefined | null): string;

/** The wire's `fields[]`, dropped of anything a browser cannot draw. */
export declare function normalizeFields(raw: unknown): PdfField[];

/**
 * The code the interface uses for a tag.
 *
 * `tr-TR` and `TR` mean `tr`; `es-MX` means `es` when a pack offers `es`;
 * `pt` means `pt-br` when that is the only Portuguese on offer; a regional
 * pack (`pt-br`, `zh-hant`) keeps its region, because Brazilian and European
 * Portuguese — or the two Chinese scripts — are different tables. A tag
 * nothing offers yet is KEPT whole, so a choice held before the list arrives
 * still means what the person picked.
 */
export declare function normalizeLocaleCode(raw: string | undefined | null): string;

/**
 * normalizeOp maps the backend ops row (`{kind,total,done,failed,error,dest,
 * status:'ok'|'failed'|'partial'|…}`) onto the PendingOp contract the tray
 * renders (`{op_type,progress_total,progress_done,error_message,status:'done'|
 * 'error'|…}`). Without this the tray showed "undefined/undefined" for a
 * running op (progress_* were undefined) and never treated an 'ok'/'failed'
 * row as terminal. Tolerant of an already-normalized shape (idempotent).
 */
export declare function normalizeOp(raw: Record<string, unknown>): PendingOp;

/**
 * A choice as a handler id. Accepts the spelling before 0.50 too
 * (`plugin/view`, what "Open in new tab" put in `app=`).
 */
export declare function normalizeOpenChoice(choice: string | null | undefined): string | null;

/** The wire's `rule`, reduced to something drawable; `null` when there is none. */
export declare function normalizeRule(raw: unknown): PdfFieldRule | null;

/**
 * accountRules — what an account's e-mail address and username may be,
 * checked WHILE the person types, by the SERVER.
 *
 * ⚠⚠ The server is the only authority and the only author (0.54 audit B15 +
 * A12). This file used to be a mirror of its rules (backend identity.Check,
 * handlers/account_rules.go) with a copy of their sentences in two
 * catalogues beside the server's own `server.account.*`: three copies of
 * every sentence, and the e-mail rule had already drifted - the browser let
 * `a,b@x` and `ada.@x` through and the save refused them. Now a form asks
 * `POST /api/auth/account/check` while it is typed and shows what the server
 * says, in the reader's language; the save refuses the same things in the
 * same words.
 *
 * Why the check exists at all (release-candidate sweep, 2026-09-21): the
 * profile saved "bu-bir-eposta-degil" as an address and answered "Profil
 * kaydedildi", and a username with "ş" came back, after Save, as the server's
 * raw English. A form says the problem under the box while it is typed.
 */
/** identity.Normalize: trimmed, lower-case — what the server will store. */
export declare function normalizeUsername(raw: string): string;

/** Any degree count as one of the four the PDF spec allows. */
export declare function normRotation(r: number | undefined | null): Rotation;

/**
 * A request got no answer at all. Raises the shared notice and says whether
 * this particular failure is the caller's to report.
 *
 * ⚠ An ACTION raises the notice too. The connection is down either way, and
 * the person's own message ("could not be renamed") does not explain why.
 */
export declare function noteRequestFailed(kind: RequestKind, now?: number): FailureVerdict;

/**
 * A request got an answer — any answer. ⚠ Including a 4xx or a 5xx: the
 * server spoke, so the connection is not what is wrong, and a notice that
 * said otherwise would be lying while the person reads a real refusal.
 */
export declare function noteRequestSucceeded(): void;

export declare const NotificationBell: DefineComponent<__VLS_Props_7, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
open: (item: NotificationRowData) => any;
manage: () => any;
}, string, PublicProps, Readonly<__VLS_Props_7> & Readonly<{
onOpen?: ((item: NotificationRowData) => any) | undefined;
onManage?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
btnEl: CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
as: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
disabled: {
type: BooleanConstructor[];
default: boolean;
};
id: {
type: StringConstructor;
default: null;
};
}>>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, Record<string, any>, VNodeProps & AllowedComponentProps & ComponentCustomProps, {
id: string;
as: string | Record<string, any>;
disabled: boolean;
}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ExtractPropTypes<    {
as: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
disabled: {
type: BooleanConstructor[];
default: boolean;
};
id: {
type: StringConstructor;
default: null;
};
}>>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, {
id: string;
as: string | Record<string, any>;
disabled: boolean;
}> | null;
}, any>;

export declare type NotificationDestination = {
    kind: 'folder';
    /** Storage name — the first segment of every explorer path. */
    storage: string;
    /** Folder inside that storage, relative, '' for its root. */
    folder: string;
    /**
     * The row to select once the folder is open, as `<storage>://<path>` —
     * the exact string the explorer puts in `data-fe-path`. Absent when the
     * target is the folder itself.
     */
    select?: string;
    /**
     * An app screen to open once the row is revealed. ⚠ It rides on the
     * DESTINATION rather than being resolved separately so the two can never
     * disagree about which file they mean — the row that is selected is the
     * row the app screen runs on.
     */
    open?: NotificationOpen;
} | {
    /**
     * The Trash view (the explorer's `.trash` sentinel), spanning every
     * storage. `select` is the row to select there, as `<storage>://<path>`
     * with the ORIGINAL path — the view lists items by where they came from.
     * Absent when the event could not say which item it was.
     */
    kind: 'trash';
    select?: string;
} | {
    kind: 'share';
    token: string;
}
/**
* An app's HOME page (`kind: "app"` — a notice about a list, not a file),
* optionally at one of its sections. The web opens its own page for it
* (the `app-home` route); a surface with no such page (the desktop app)
* brings its window forward and stops.
*/
| {
    kind: 'app';
    plugin: string;
    view: string;
    section?: string;
} | {
    kind: 'none';
};

/** Where the encrypted names of a sentence stand (backend model.NotificationE2E). */
export declare interface NotificationE2E {
    title: NotificationTextPart[];
    body: NotificationTextPart[];
    names: NotificationE2EName[];
}

/** One name inside an encrypted folder (backend model.NotificationE2EName). */
export declare interface NotificationE2EName {
    /** The item as listings address it, `<storage>://<path>`, as stored. */
    wire: string;
    /** The encrypted folder it is in, `<storage>://<root>`. */
    root: string;
    /** `name` - the item's own name; `path` - where it is. */
    part: string;
    /** What it reads as without the key: what `title`/`body` already say. */
    locked: string;
}

/**
 * The feed as the components read it: refs unwrapped, the way a pinia store
 * and a `reactive()` both hand it over. The bell and the full-list screen take
 * this, never the raw refs, so one component works under either host.
 */
export declare interface NotificationFeed<T extends NotificationRowData = NotificationRowData> {
    readonly feed: T[];
    readonly feedLoading: boolean;
    readonly unreadCount: number;
    readonly hasUnread: boolean;
    readonly mine: T[];
    readonly mineTotal: number;
    readonly mineLimit: number;
    readonly mineOffset: number;
    readonly mineUnreadOnly: boolean;
    readonly mineLoading: boolean;
    readonly mineError: string | null;
    readonly panelOpen: boolean;
    refreshFeed(): Promise<boolean>;
    fetchUnread(): Promise<void>;
    syncUnread(): Promise<void>;
    acceptCount(count: number): Promise<void>;
    fetchMine(): Promise<void>;
    setMinePage(p: number): void;
    setMineUnreadFilter(u: boolean): void;
    openPanel(): void;
    closePanel(): void;
    markRead(id: number): Promise<void>;
    markAllRead(): Promise<void>;
}

export declare interface NotificationFeedOptions<T extends NotificationRowData> {
    transport: NotificationsTransport<T>;
    /** What a failed page load says (the full-list screen prints it). */
    errorText?: (err: unknown) => string;
    /**
     * Other lists on screen that hold the same rows and must stop looking unread
     * the moment one is read here — the web's admin audit table.
     */
    alsoStamp?: () => Ref<T[]>[];
    /**
     * Told after a row (or every row) was marked read here — so a badge the host
     * draws itself (the desktop app's dock and tray) moves at once instead of on
     * its next poll.
     */
    onRead?: () => void;
}

/**
 * The destination as a plain ADDRESS, for the places that cannot push a
 * route: a service worker's `notificationclick` (which has no router, and may
 * run with no page open at all) and anything that wants a copyable link.
 *
 * `base` is the prefix the SPA is served from (`/admin/`, `/drive/`, under
 * the base path when there is one) — the same reason `pluginPageBase` exists
 * on the explorer's config: only those prefixes fall back to index.html on the
 * server. `root` is the base path alone, for a share link (shareHref).
 *
 * ⚠ Hand-rolled escaping rather than `URLSearchParams`: this module is
 * imported by the DESKTOP MAIN PROCESS and by a service worker, and its whole
 * discipline is to depend on nothing. `''` when there is nowhere to go — the
 * caller must not turn that into "/".
 */
export declare function notificationHref(dest: NotificationDestination, base?: string, root?: string): string;

/** The shape this module reads - structural, so any row type passes. */
export declare interface NotificationLike {
    event: string;
    title?: string;
    body?: string;
    e2e?: NotificationE2E | null;
}

/**
 * Where a click actually goes. Deliberately NOT a URL: the desktop app has no
 * URLs to navigate — it hands the explorer component a path — so the shared
 * answer is the structured destination and each surface renders it its own way
 * (`notificationRoute` below for the web, IPC for the desktop).
 */
/** What an app wants opened once the file is on screen. */
export declare interface NotificationOpen {
    plugin: string;
    action?: string;
    view?: string;
}

/** A route the web SPA can push. `null` when the destination is not in-SPA. */
export declare function notificationRoute(dest: NotificationDestination): {
    name: string;
    params?: Record<string, string>;
    query: Record<string, string>;
    hash: string;
} | null;

export declare const NotificationRow: DefineComponent<__VLS_Props_8, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
open: (item: NotificationRowData) => any;
}, string, PublicProps, Readonly<__VLS_Props_8> & Readonly<{
onOpen?: ((item: NotificationRowData) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/**
 * One notification, as far as the bell is concerned. The web's `NotificationItem`
 * carries more (the admin columns); every field here is one it has too.
 */
export declare interface NotificationRowData {
    id: number;
    event: string;
    severity: string;
    /** The sentence, said by the server in the reader's language (backend
     *  notify say.go) - shown as it is. */
    title?: string;
    body?: string;
    meta?: unknown;
    target?: NotificationTarget | null;
    /** Where an encrypted item's name stands in title/body, for a screen that
     *  can name it (lib/notificationText). Absent on every other row. */
    e2e?: NotificationE2E | null;
    /** Whether a click on the row goes somewhere - the server's verdict
     *  (backend notify.Opens; lib/notificationTarget rowOpens). */
    opens?: boolean | null;
    read_at?: string | null;
    created_at: string;
}

export declare const NotificationsPanel: DefineComponent<__VLS_Props_9, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
open: (item: NotificationRowData) => any;
}, string, PublicProps, Readonly<__VLS_Props_9> & Readonly<{
onOpen?: ((item: NotificationRowData) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** The four user-scoped endpoints the feed reads (docs/NOTIFICATIONS.md →
 *  "In-app bell (endpoints)"). None of them needs administrator rights. */
export declare interface NotificationsTransport<T extends NotificationRowData = NotificationRowData> {
    list(params: {
        unread?: boolean;
        limit?: number;
        offset?: number;
    }): Promise<{
        items?: T[] | null;
        total?: number;
    }>;
    unreadCount(): Promise<number>;
    markRead(id: number): Promise<void>;
    markAllRead(): Promise<void>;
}

/**
 * The four endpoints over the explorer's own client — for a host that hands
 * the explorer a credential rather than a store (the desktop app, an embed).
 *
 * `jsonFetch` is `useFileApi(config).jsonFetch`, so the request carries the
 * explorer's auth, its language and its credentials mode, exactly like every
 * listing it makes. `base` is the server root (`connectionsBase(config)`).
 *
 * ⚠ No language is named: the server says each row in the language of the
 * reader's ACCOUNT (backend notify say.go, PersonLang) - the one setting the
 * bell, the push, the email and the desktop toast all read, whichever surface
 * set it. An embed whose host draws the explorer in another language still
 * gets its notifications in the account's (#191, translated at the last
 * stop: the person's).
 */
export declare function notificationsTransport(jsonFetch: <R>(url: string, init?: RequestInit) => Promise<R>, base: string): NotificationsTransport;

/**
 * The typed target the backend puts on every notification row and every
 * webhook body (`docs/NOTIFICATIONS.md` → "Click target").
 *
 * `storage` is the storage NAME — the explorer addresses storages by name and
 * a numeric id is unreadable to a caller who cannot list them. `path` is
 * relative to that storage's root and never carries a `<storage>://` prefix.
 */
export declare interface NotificationTarget {
    kind: NotificationTargetKind;
    storage?: string;
    path?: string;
    id?: string;
    /**
     * An app plugin asked for one of ITS OWN screens to be opened on the file
     * (`notify_send target.action|view`, docs/APP-PLUGINS-API.md → v2). The
     * server validates that the named action/view belongs to the named plugin
     * before storing this, so a client may act on it without re-checking.
     *
     * ⚠ This is the difference between "a file you have nothing to do with
     * changed" and "please sign this": a `plugin.notice` that lands you in a
     * folder has made you find the screen yourself, which for a signer is
     * where the flow stops.
     */
    open?: {
        plugin: string;
        action?: string;
        view?: string;
        section?: string;
    };
}

/**
 * What a notification is about. Mirrors `model.NotificationTargetKind` (Go).
 *
 * `trash` is the Trash view with the item that was deleted from `path` (its
 * ORIGINAL path, in `storage`) selected — what a soft delete and an antivirus
 * quarantine address. ⚠⚠ It exists because the only address those events used
 * to carry was the item's key inside the bin: `{kind: 'file', path:
 * '.filex-trash/<key>'}`, which opened the bin's raw folder — breadcrumb
 * `docs › .filex-trash`, nothing listed, nothing to restore (owner's report,
 * 2026-09-21). An older client that does not know this kind resolves it to
 * `none` below, which is honest: the row reads, and goes nowhere.
 *
 * `app` is one of an app plugin's HOME pages (`open.plugin` + `open.view`,
 * optionally `open.section`) — a notice about a list rather than a file.
 */
export declare type NotificationTargetKind = 'file' | 'dir' | 'share' | 'trash' | 'app' | 'none';

/**
 * A notification's words, as the SERVER said them.
 *
 * ⚠⚠ The sentence is composed on the server, in Go, and nowhere else
 * (backend internal/notify say.go; the maintainers' decision, 2026-10-08:
 * "the browser sends a key and its values; the server builds the sentence and
 * sends it where it goes"). `GET /api/notifications` answers every row with
 * its `title` and `body` already said in the reader's language - a language
 * pack's included, right to left isolated - and the same code path says the
 * same row to a phone (Web Push), in an email and to a webhook. This module
 * composes NOTHING: there is no phrase table, no template and no plural rule
 * on this side any more (web/tests/quality/noClientNotificationText.test.ts
 * holds that).
 *
 * The one thing it does is the one thing the server cannot: the name of an
 * item inside an end-to-end encrypted folder, which the server only has
 * scrambled. Such a row says "🔒 Encrypted item" there, and carries `e2e` -
 * the same sentence cut at the names, and what each name is. A reader whose
 * explorer has that folder unlocked puts the real name in its place; every
 * other reader (the desktop app's toast, a push, an email) shows the server's
 * words as they are.
 *
 * ⚠ Plain TypeScript with no import and no framework: the bell (NotificationRow,
 * in the web and in the desktop app's window), the page's pop-up
 * (web useNotificationWatcher) and the admin history all read through it.
 */
/** One notification as a screen shows it. */
export declare interface NotificationText {
    title: string;
    body: string;
}

/**
 * The words a screen shows for one row: the server's, with an encrypted
 * item's real name where this reader can name it.
 */
export declare function notificationText(row: NotificationLike, e2eName?: E2eNameResolver_2): NotificationText;

/** One piece of a sentence: words, or the name at `names[name]`. */
export declare interface NotificationTextPart {
    text?: string;
    name?: number;
}

/** The bell's cadence, on every surface that polls (the web's watcher, the
 *  explorer's own loop). Do not lower it: a quiet instance costs one small
 *  request per tick, per open window. */
export declare const NOTIFY_POLL_MS = 15000;

/**
 * Offer the tour once, `delayMs` after a mount, unless this person has already
 * been offered it. Returns a cancel for the unmount.
 *
 * With an account behind the explorer the decision waits for the account's
 * answer (at most `accountWaitMs`), so a person who took the tour on another
 * device is not shown it again while the answer is on its way.
 */
export declare function offerTourOnce(show: () => void, opts?: {
    delayMs?: number;
    accountWaitMs?: number;
}): () => void;

/**
 * The kinds ONLYOFFICE opens as ONE choice among others: filex's own viewer
 * opens them too (a read-only table for a CSV), so "Open with" offers both.
 * ⚠ The twin of backend assoc `onlyOfficeOpenKinds`; a test holds the two
 * together. The office kinds (docx, xlsx...) are not here: ONLYOFFICE is the
 * only thing that opens them, there is nothing to choose.
 */
export declare const OFFICE_OPEN_KINDS: readonly string[];

/** ONLYOFFICE is an open handler of this kind (an extension, no dot). */
export declare function officeOpensKind(ext: string | null | undefined): boolean;

/** ONLYOFFICE's editor, as a handler id (filex 0.51, backend assoc.OnlyOffice). */
export declare const ONLYOFFICE_VIEWER = "onlyoffice";

/** What the capabilities answer says about the document server. */
declare interface OnlyOfficeCaps {
    onlyoffice_url?: string | null;
    external?: {
        onlyoffice?: ExternalServiceStatus;
    };
}

/**
 * ONLYOFFICE is configured and answering, by the capabilities answer: the
 * probe did not fail (`external.onlyoffice`) and there is an address. The
 * explorer reads the same two fields (FileExplorer effectiveOnlyOfficeBase),
 * so "Open with ONLYOFFICE" means the same thing in Settings.
 */
export declare function onlyOfficeUsable(caps: OnlyOfficeCaps | null | undefined): boolean;

/** Be told when the account's answer arrives or changes. Returns the unsubscribe. */
export declare function onPrefs(fn: (p: UiPrefs) => void): () => void;

/** Be told once the account's answer is in (or known not to be coming). Returns the unsubscribe. */
export declare function onPrefsSettled(fn: () => void): () => void;

/** Be told when the stored preferences have been applied (the first load and
 *  every refresh that wins). */
export declare function onViewPrefsApplied(fn: () => void): () => void;

/**
 * The physical `left` of a floating box opened at `anchor` (a viewport x):
 * it opens toward the inline END — down-right of the pointer in LTR,
 * down-LEFT in RTL — flips to the other side of the anchor when that would
 * overflow the viewport, and clamps when neither side fits.
 *
 * ⚠ Written ONCE, as the LTR rule, and mirrored by mapping x → viewport − x:
 * the RTL behaviour is the LTR behaviour seen in a mirror by construction,
 * and the LTR answer is byte-for-byte what the menus did before RTL existed.
 */
export declare function openAlongInline(anchor: number, size: number, viewport: number, dir: TextDirection, margin?: number): number;

/**
 * A notification's deep link (`target.open`): show the file and open what the
 * app asked for on it — its action, or its view.
 *
 * ⚠⚠ Why this is exposed rather than a config prop. A bell click does not
 * remount anything: the person is already standing in the explorer, the hash
 * changes, the listing reloads. An `initialPluginAction` prop would fire once,
 * at mount, and every click after the first would land on the file and stop
 * there — which is the bug this whole field exists to fix ("please sign" that
 * drops you in a folder instead of in the signing screen).
 *
 * ⚠ The row may not be in the listing yet (a fresh tab, a folder still
 * loading), so a path that is not on screen is carried as a bare node. The
 * server re-checks `applies` and the ACL on every run, so the worst case is
 * an honest 422 rather than a wrong screen.
 *
 * ⚠⚠ It AWAITS the capability answer before reading `pluginsEnabled`. That
 * flag comes from `GET /api/capabilities`, which the explorer asks for in its
 * own `onMounted` — so whether this function found it filled was a matter of
 * which of two unrelated requests came back first. Measured as "roughly one
 * opening in eight the signing screen does not come up"; it was never the
 * plugin LIST (that was already awaited two lines down), it was the flag
 * gating it. Awaiting the promise removes the timing question instead of
 * betting on it.
 *
 * ⚠ Every refusal below now SAYS something. Four `return false`s in this path
 * were silent, and a deep link that silently does nothing is the hardest
 * possible bug to report: the person clicked a notification, the folder
 * opened, and the thing they were asked to do never appeared.
 */
declare function openAppTarget(p: {
    plugin: string;
    action?: string;
    view?: string;
    path: string;
}): Promise<boolean>;

/** One handler that opens a file: an app's interface, or filex's own (view null). */
export declare interface OpenHandler {
    id: string;
    view: PluginViewRow | null;
}

/** The handler id of an app's interface. */
export declare function openHandlerId(v: Pick<PluginViewRow, 'plugin' | 'id'>): string;

/** What only the host knows about a file's handlers. */
export declare interface OpenHandlerOptions {
    /**
     * ONLYOFFICE is configured and answering here (the capabilities probe, the
     * same answer the office documents' Open reads). Absent or false: it opens
     * nothing, and a choice of it falls through to the next handler.
     */
    onlyOffice?: boolean;
}

/** What the administrator's rule makes of a file's handlers. */
export declare interface OpenHandlers {
    /** The handlers that are on, in the order they are offered. */
    on: OpenHandler[];
    /** The ones switched off for the file's kind. */
    off: OpenHandler[];
    /** An administrator's rule decided the order. */
    custom: boolean;
}

/** The handlers of a file, ordered and switched off by the rule for its kind. */
export declare function openHandlersFor(views: readonly PluginViewRow[], node: NodeLike, rules?: Readonly<Record<string, OpenRule>> | null, opts?: OpenHandlerOptions | null): OpenHandlers;

/**
 * The folder part of an adapter-qualified path, as the explorer's hash wants
 * it (`storage/dir/sub`), and the file itself for `?select=`.
 */
export declare function openHashFor(qualified: string): string;

/** A file's kind: its extension, lower-case, no dot ('' for none). */
export declare function openKindOf(node: NodeLike): string;

declare function openPanel(seed?: string): Promise<void>;

/**
 * 0.50 - the administrator's rule for which handler opens a kind of file
 * (Admin → Plugins → Default apps; backend internal/assoc): the handlers
 * offered first, in this order, and the ones switched off. Handler ids are
 * `builtin` (filex's own viewer) and `app:<plugin>/<view>`.
 */
export declare interface OpenRule {
    order: string[];
    off: string[];
}

/**
 * Where this answer sends the person.
 *
 * `''` when there is nowhere to go: no path, or a frame with no explorer
 * behind it. The caller draws its screen and does nothing, which is what a
 * public page must do.
 */
export declare function openTargetFor(req: SurfaceOpenRequest | null | undefined, opts: SurfaceOpenOptions): SurfaceOpenTarget;

/** The person's choice for a kind, null for none. Reactive. */
export declare function openWithChoice(ext: string | null | undefined): string | null;

/** Every choice this person made, by kind. Reactive. */
export declare function openWithChoices(): Record<string, string>;

export declare interface Operation {
    /** `${group}:${id}` — unique across publishers. */
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    errorDetail: string | null;
    queued: boolean;
    cancelling: boolean;
    doneCount: number | null;
    totalCount: number | null;
    itemsDone: number | null;
    itemsTotal: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    message: string | null;
    outputs: string[];
    outputMode: string | null;
    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;
    /** Reveal one of the row's outputs in the listing. */
    open?: (path: string) => 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;
    /** The failure, SAID (lib/errorWords) — never a raw server string. */
    error?: string | null;
    /** The raw words behind it — set only for a caller who administers the
     *  instance; drawn as a second line under the sentence. */
    errorDetail?: string | null;
    /** Queue op accepted but not started yet ("Queued"). */
    queued?: boolean;
    /** Cancellation was accepted and the worker is stopping/cleaning up. */
    cancelling?: boolean;
    /** Progress counters for queue ops (3/5 items). */
    doneCount?: number;
    totalCount?: number;
    /** The items one source is made of, when the server counts them (a folder
     *  job on one storage): "25 of 100 items" instead of a source count of 0/1. */
    itemsDone?: number;
    itemsTotal?: number;
    /** Byte progress for uploads. */
    uploadedBytes?: number;
    totalBytes?: number;
    cancellable?: boolean;
    retryable?: boolean;
    /** A plugin job's last progress message — shown under the name while it runs. */
    message?: string | null;
    /** Files a finished job produced (adapter-qualified paths); the row offers "Open". */
    outputs?: string[];
    /**
     * An app-plugin job's output mode — `sibling` (a new file beside the
     * original) or `version` (the same file, a new version of it).
     *
     * ⚠ It is on the row because the two are indistinguishable once the job
     * lands: "Open" navigates to `outputs[0]`, which in `version` mode IS the
     * input the person started from, so without the chip the tray reads as if
     * nothing was produced. Absent for every other kind.
     */
    outputMode?: string | null;
}

/**
 * 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).
 */
/** `plugin` — an app-plugin job (docs/APP-PLUGINS-API.md); also what any
 *  queue kind this package has no drawing for is shown as. */
export declare type OperationKind = 'upload' | 'copy' | 'move' | 'delete' | 'rename' | 'restore' | 'purge' | 'convert' | 'archive' | 'archive-create' | 'archive-extract' | 'plugin' | 'trash' | 'thumbs';

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

export declare type OperationsStore = ReturnType<typeof useOperations>;

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

/**
 * The objects ONE source is made of, when its storage driver counts them (a
 * folder job on one storage): "25 of 100 items" rather than a source count of
 * 0/1 — or null. ⚠ The one copy of this rule: #67 wrote it here, in the
 * explorer's PendingOpsTray and in the admin app's.
 */
export declare function opObjects(op: OpProgressLike): {
    done: number;
    total: number;
} | null;

/** 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%;
 *   - a single source whose storage driver counts the objects it works
 *     through (`objects_done` / `objects_total`: one folder on an object store
 *     is minutes of objects) draws those;
 *   - 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;
    objects_total?: number;
    objects_done?: number;
}

/** What a storage has to carry to be ordered. `ExplorerConfig.storages` rows fit. */
export declare interface OrderableStorage {
    name: string;
    uid?: string;
    label?: string;
    /** The administrator's position (1 = first); null/absent = not placed. */
    sortOrder?: number | null;
}

/**
 * The storages in the order this person sees them: theirs over the
 * administrator's over the host's (the header has the rule).
 *
 * ⚠ The host's rows are returned as they came (same objects, every field
 * intact), only reordered. The person's order is applied by SLOT: the
 * positions the default order gives the storages the person named are
 * re-filled with those storages in the person's order; every other storage
 * stays exactly where the default order put it.
 */
export declare function orderStorages<T extends OrderableStorage>(storages: readonly T[], saved: readonly string[]): T[];

/**
 * Reload without asking only when nothing of this editor's would be lost.
 *
 * ⚠ "Edited" is sticky for the life of one editor: ONLYOFFICE's
 * onDocumentStateChange says `true` while the person types and `false` once
 * the edits have reached the DOCUMENT SERVER — not the file. The file gets
 * them only when the session ends (or on a forced save), so `false` must not
 * be read as "saved".
 */
export declare function outsideAction(edited: boolean, change: Pick<OutsideChange, 'pending'>): 'reload' | 'ask';

/** The viewer's answer to its host. */
export declare interface OutsideAnswer {
    seq: number;
    choice: OutsideChoice;
    /** The path the document is open at now (the new one after a reload). */
    path: string;
    /** The office session the answer is about (ONLYOFFICE `document.key`), when
     *  there was one: the server needs it to know which save to keep where. */
    key?: string | null;
    /**
     * Who noticed the change: the host (its `outsideChange` prop - the desktop
     * app) or the viewer itself, from the server's realtime feed. Only a host's
     * change is the host's to act on; the viewer tells the server about its
     * own (officeSession).
     */
    origin?: 'host' | 'server';
}

/** One change, handed to the viewer by its host. */
export declare interface OutsideChange {
    /** Rises with every change the host sees: the same change delivered twice
     *  is one change, and an answer names the change it answers. */
    seq: number;
    /**
     * Where the new version is, when it is not where the open document is. The
     * desktop app puts each outside version on the server as a NEW working copy
     * (so a late save of the old editor session can never land on it); the web
     * reloads the same path and leaves this out.
     */
    path?: string | null;
    /** The host holds a save of this editor's that is not written yet: the
     *  question is asked even when the editor has no unsaved edit of its own. */
    pending?: boolean;
}

/** What became of a change. 'reloaded' = it was taken in without a question. */
export declare type OutsideChoice = 'reloaded' | 'theirs' | 'mine' | 'both';

/** What a language wrote ITSELF, and whose plural rules read it. */
export declare interface OwnLocaleTable {
    /** The language whose CLDR plural rules pick a form out of `strings`. */
    lang: string;
    /** Its own words only — English is NOT merged underneath. */
    strings: Readonly<Record<string, string>>;
}

/** Every outward-facing page token a theme MAY define (none is required). */
export declare const PAGE_TOKENS: readonly string[];

/** The rendered viewport at scale 1: its size after rotation, and that rotation. */
declare interface PageBox {
    width: number;
    height: number;
    rotation: number;
}

/**
 * `/api/p/{token}` — an app plugin's page.
 *
 * ⚠ Retired by v3 (§1: "`/p/*` — retired, 301 to the share"). Kept because
 * links already in people's mailboxes point at it and a 301 only helps a
 * browser that follows one; nothing new should be built on it.
 */
export declare function pageRoot(base: string | undefined, token: string): PublicRoot;

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

export declare const PANEL_SEARCH_FILES_CAP = 3;

/** How many rows a group shows without a prefix, and with one. */
export declare const PANEL_SEARCH_GROUP_CAP = 6;

/**
 * The order the groups are drawn in. Fixed rather than by best score: a
 * person learns where to look, and the panel's own places come before the
 * records in it. One exception: a group whose best row is NAMED what was
 * typed comes first (`panelSearchGroups`).
 */
export declare const PANEL_SEARCH_KINDS: readonly PanelSearchKind[];

/** The prefixes in the order the hint line shows them. */
export declare const PANEL_SEARCH_PREFIX_ORDER: readonly string[];

export declare const PANEL_SEARCH_PREFIXED_CAP = 25;

/**
 * The prefixes, and the kind each narrows to. English words in every
 * language, like the explorer's `tag:`: a prefix is a command, and one
 * spelling is what a guide and a colleague can say.
 */
export declare const PANEL_SEARCH_PREFIXES: Readonly<Record<string, PanelSearchKind>>;

/** One drive as the navigation panel holds it (`ExplorerConfig.storages`). */
export declare interface PanelDrive {
    name: string;
    usedBytes?: number;
    usedPartial?: boolean;
}

/**
 * Is the whole query this item's name - its label or one of its terms (not
 * a synonym)? "Çöp kutusu saklama" is the setting's name, not a page's.
 */
export declare function panelExact(item: PanelSearchItem, words: readonly string[]): boolean;

/** One of a person's recent searches, as the host's store keeps it. */
export declare interface PanelRecentSearch {
    id: number | string;
    query: string;
}

/**
 * Where the recent searches live - the server, per person (migration 00090):
 * the host wires these to its API. Every call may fail; the panel then shows
 * the list it had.
 */
export declare interface PanelRecentStore {
    list(): Promise<PanelRecentSearch[]>;
    add(query: string): Promise<void>;
    remove(id: PanelRecentSearch['id']): Promise<void>;
    clear(): Promise<void>;
}

/**
 * How well an item answers the words: -1 for not at all, higher for better.
 *
 * Every word has to be somewhere - the label, a term, an alias or the detail
 * line - and each counts for where it was found: the start of the label most,
 * a term less, an alias less again, the detail line least. The whole query
 * being the label (or a term, or an alias) outright wins over everything, so
 * "Uygulamalar", "apps" and "uygulama" put the Apps page first.
 *
 * A row the server or the file index already matched (`found`) is never -1:
 * what it was found by may not be on the row.
 */
export declare function panelScore(item: PanelSearchItem, words: readonly string[]): number;

export declare const PanelSearch: DefineComponent<__VLS_Props_14, {
openPanel: typeof openPanel;
close: typeof close_2;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
choose: (item: PanelSearchItem) => any;
}, string, PublicProps, Readonly<__VLS_Props_14> & Readonly<{
onChoose?: ((item: PanelSearchItem) => any) | undefined;
}>, {
compact: boolean;
files: (text: string, limit: number) => Promise<PanelSearchItem[]>;
recent: PanelRecentStore;
remote: (query: PanelSearchQuery) => Promise<PanelSearchItem[]>;
shortcut: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
trigger: HTMLButtonElement;
layer: HTMLDivElement;
inputEl: HTMLInputElement;
listEl: HTMLDivElement;
}, HTMLDivElement>;

/** One group as it is drawn. */
export declare interface PanelSearchGroup {
    kind: PanelSearchKind;
    items: PanelSearchItem[];
    /** How many matched before the group was cut to its cap. */
    total: number;
}

/**
 * The groups for a query, each sorted by score and cut to its cap. A group
 * whose best row is NAMED what was typed (`panelExact`) comes first - the
 * setting "Trash retention" before the Trash page that merely mentions
 * retention - and the rest follow in `PANEL_SEARCH_KINDS` order. A prefix
 * keeps its own kind alone. An empty query has no groups (the panel shows the
 * recent searches instead).
 */
export declare function panelSearchGroups(items: readonly PanelSearchItem[], query: PanelSearchQuery, caps?: Partial<Record<PanelSearchKind, number>>): PanelSearchGroup[];

/** One row the search can offer. */
export declare interface PanelSearchItem {
    /** Unique across every kind (`page:users`, `user:12`, `file:3:/a.txt`). */
    id: string;
    kind: PanelSearchKind;
    /** What the row says, in the interface's language. */
    label: string;
    /** The second line: where it lives, an address, an owner. */
    detail?: string;
    /**
     * Other names it answers to and does not show: its English label, another
     * language's name of an app, a person's username.
     */
    terms?: readonly string[];
    /**
     * Synonyms ("LDAP" for Identity providers): weaker than a name, so a row
     * NAMED what was typed comes before a row that is only LIKE it.
     */
    aliases?: readonly string[];
    /** A glyph from the HOST's icon set, drawn as a component (the menu's own). */
    icon?: Component;
    /** Or a glyph from the core icon library, by name (`lib/actionIcons`). */
    iconName?: string;
    /** A file row's folder-ness: a file row wears the listing's own tile. */
    isDir?: boolean;
    /**
     * Found by a search that already matched it (the server's, the file
     * index's): drawn even when the words are not in what the row SAYS - a
     * file found by its content, a person found by an address the row does not
     * print. Ranked by the same rule as every other row.
     */
    found?: boolean;
    /** Whatever the host needs to go there; handed back untouched. */
    target?: unknown;
}

/** What an item is, and the group it is drawn under. */
export declare type PanelSearchKind = 'page' | 'setting' | 'app' | 'user' | 'group' | 'key' | 'storage' | 'share' | 'file';

/** A typed query, taken apart. */
export declare interface PanelSearchQuery {
    /** The kind a prefix narrows to, or null for none. */
    kind: PanelSearchKind | null;
    /** The prefix as a word (`file`), '' for none. */
    prefix: string;
    /** What is searched for, the prefix taken off, trimmed. */
    text: string;
    /** `text` folded and split into words. */
    words: string[];
}

/** Every row of the groups, in the order they are drawn (the keyboard's order). */
export declare function panelSearchRows(groups: readonly PanelSearchGroup[]): PanelSearchItem[];

/** `text` folded (`foldText`) and split into words. */
export declare function panelWords(text: string): string[];

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

declare interface ParsedFxe {
    header: FxeHeader;
    /** Required features this build does not know. Non-empty: do not open it. */
    unsupported: string[];
    /** Bytes before the body (13 + header length). */
    prefixLength: number;
}

/**
 * Parse marker JSON text; returns null when the shape is not a marker this
 * build can OPEN — including a v3 marker that requires a feature it does not
 * know. Callers that want to explain a refusal use `parseMarkerDetailed`.
 */
export declare function parseMarker(text: string): E2eMarker | null;

/**
 * The query taken apart. A prefix counts only as one of the known words
 * followed by a colon at the very start (`file:rapor`, `User: ada`); any
 * other `word:` is searched for as it is, so `C:` or `12:30` is not lost.
 */
export declare function parsePanelQuery(raw: string): PanelSearchQuery;

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

/**
 * The stored form → a list of keys. Anything that is not a JSON list of
 * strings reads as "no order": a preference is never worth an exception, and
 * a damaged value must fall back to the host's order, not to a blank panel.
 */
export declare function parseStorageOrder(raw: unknown): string[];

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

export declare const PDF_FIELD_TYPES: readonly ["signature", "initials", "date", "text", "checkbox"];

export declare const PDF_RULE_KINDS: readonly PdfRuleKind[];

export declare interface PdfField {
    id: string;
    type: PdfFieldType;
    /**
     * v3 3.1 - what the field is CALLED ("Ad soyad", "Imza", "Tarih").
     *
     * The reason it exists: a signer was shown a whole document and told to
     * find their boxes. A named field can be listed, asked for and reported -
     * the label shows in the box, in the fill form and in the audit trail - and
     * three boxes of the same type on one page stop being indistinguishable.
     * Absent: the type's own name stands in, which is what every field placed
     * before v3 has.
     */
    label?: string;
    /** 1-based. */
    page: number;
    x: number;
    y: number;
    w: number;
    h: number;
    /** A signer id (`signers[].id`). Absent: anybody's. */
    assignee?: string;
    required?: boolean;
    /**
     * v3 3.3 - false while the box has been DEFINED but not yet put on the
     * page.
     *
     * Naming a box and finding a place for it are two different jobs, and
     * doing them in one screen is what made the wizard's hardest step: a
     * palette of types, a rectangle drawn under the pointer and a strip of
     * properties for whichever box happened to be selected. Defined first,
     * placed after: the `define` screen writes boxes with `placed: false`,
     * and `place` hands them out one at a time. Absent means placed, so every
     * field written before this (and every other plugin's) reads as it did.
     */
    placed?: boolean;
    value?: unknown;
    /**
     * `text` only: what the box accepts (`lib/pdfFieldRules`). Enforced while
     * the person types and echoed back with the value, so the stamping plugin
     * formats what it is handed instead of guessing from the string.
     */
    rule?: PdfFieldRule;
    /**
     * `date` only: which layout the date is written in, as one of the ids the
     * surface offered in its `formats` prop (`DD.MM.YYYY`, `MM/DD/YYYY`,
     * `YYYY-MM-DD` for the signing app). It is the date field's answer to what
     * `rule` is for a text one, and it has to SURVIVE the round trip: a box
     * whose layout is dropped here comes back to the plugin as "no layout" and
     * is stamped in whatever that plugin defaults to — a form that asked for
     * `12/31/2000` quietly starts printing `31.12.2000`.
     *
     * ⚠ Not narrowed to a fixed set on purpose: the catalogue belongs to the
     * plugin, not to this package.
     */
    format?: string;
    /**
     * The face the words are drawn in — one of `lib/signFonts`' five keys. On
     * a `signature`/`initials` field it is the typed-signature face (and only
     * means something when `style` is `typed`); on a `text`/`date` one it is
     * the face the stamper should use. Absent = the screen's default.
     */
    font?: SignFontKey;
    /**
     * `signature`/`initials` only: drawn by hand (absent) or a name typed in
     * `font`. The requester decides; the signer's pad then offers exactly that.
     */
    style?: PdfSignatureStyle;
    /**
     * `signature`/`initials` only: which of the plugin's `stamp_lines` are
     * printed under this signature, by id. Absent = the plugin's default set;
     * `[]` = nothing under it.
     */
    lines?: string[];
}

export declare interface PdfFieldRule {
    kind: PdfRuleKind;
    /** Shortest accepted length in characters (0 = no floor). */
    min?: number;
    /** Longest accepted length in characters (0 = no ceiling). */
    max?: number;
}

/** Where a `pdf-fields` node's document comes from — exactly one of the three. */
declare interface PdfFieldsSource {
    /** An exposed copy on a public page. */
    ref?: string;
    /** Adapter-qualified path of a storage file (the explorer's authenticated preview fetch). */
    path?: string;
    /** Any URL the browser may fetch. */
    url?: string;
}

export declare type PdfFieldType = (typeof PDF_FIELD_TYPES)[number];

/** One entry of fill mode's answer. `label`/`font`/`rule` ride along when the field has them. */
export declare interface PdfFillEntry {
    id: string;
    value: unknown;
    /** v3 3.1 - the field's name, so the audit trail says what was filled in. */
    label?: string;
    font?: SignFontKey;
    rule?: PdfFieldRule;
}

/**
 * pdfjsLoader — the ONE way this package brings pdf.js in.
 *
 * `pdfjs-dist` is ~600 KB and an optional peer, so it is imported lazily and
 * its absence is an answer (`null`), not an exception. The worker script is
 * a separate file the browser fetches: the host may point at its own copy
 * (`pdfWorkerUrl` in the explorer config) and otherwise the pinned version
 * is taken from jsDelivr. `viewers/PdfViewer.vue` and the sign track's
 * `pdf-fields` node both open documents through here, so the legacy build,
 * the worker rule and the fallback cannot drift between them.
 */
/** The subset of the library the callers use; `any` on purpose — pdf.js ships no stable types for the legacy build. */
declare type PdfjsLib = any;

/** A box in PDF user space: points, origin bottom-left of the unrotated page. */
declare interface PdfRect {
    x: number;
    y: number;
    w: number;
    h: number;
}

/** Codes `ruleErrorText` turns into words; `''` when the value is acceptable. */
export declare type PdfRuleError = '' | 'number' | 'email' | 'min' | 'max';

/**
 * pdfFieldRules — what a `text` field on a PDF will accept, as pure data.
 *
 * A signing app does not only want "a box for some words": it wants a tax
 * number that is digits, a date in the shape the paper form prints, an
 * address that fits the line. So a `text` field may carry a `rule`, and the
 * browser enforces it WHILE the person types rather than after they submit —
 * an invalid signature page that only says so on the way out is a page that
 * gets signed twice.
 *
 * ⚠ The rule travels back to the plugin with the value
 * (`{fields: [{id, value, font?, rule?}]}`, docs/APP-PLUGINS-API.md →
 * `pdf-fields` props) so the stamper formats what it is handed instead of
 * guessing from the string: `01/02/2026` is a date to a rule and ambiguous
 * text to a parser.
 *
 * ⚠⚠ This is a CONVENIENCE, not the boundary (0.54, #212). The HOST decides:
 * it normalises every text box's `rule` before the screen leaves it
 * (backend/internal/wasmplugin/surface_values.go NormalizePdfRule, so the
 * rule read here is the one it judges by), and at submit it refuses a value
 * that breaks the rule, in its own words, and hands the app each box with
 * the node's own rule and label — not the ones the browser sent back. A fill
 * page posts nothing while it is typed into, so this file keeps only what
 * the signer needs on the spot: the keyboard, the shaping, and the hint
 * under the box. `web/tests/lib/pdfFieldRules.test.ts` and the Go judge read
 * the same cases (`pdf_rule_cases.json`), so the two cannot drift apart.
 */
/**
 * What a `text` field accepts. `any` is the default and means "anything".
 *
 * ⚠⚠ v3 §3.3 — there is no `date` rule any more. `date` is a FIELD TYPE,
 * and two ways to ask for the same thing is how you get two answers: a date
 * placed as a date field arrived as `YYYY-MM-DD` and a date typed into a text
 * field under the old rule arrived as `DD/MM/YYYY`, so the stamping plugin
 * had to guess which of its own boxes it was looking at. An older manifest's
 * `kind: "date"` is read as `any` rather than refused — the box keeps taking
 * what the person types, it just stops pretending to be a second date
 * control.
 */
export declare type PdfRuleKind = 'any' | 'number' | 'email';

/**
 * How a signature or initials box is given: a drawing (the pad's draw or
 * upload), or a name typed in one of the shipped faces. Absent = drawn.
 */
declare type PdfSignatureStyle = 'drawn' | 'typed';

export declare interface PdfSigner {
    id: string;
    label: PluginText | string;
    color?: string;
}

/** PDF user-space rectangle → fractions of the rendered page. */
export declare function pdfToFrac(r: PdfRect, page: PageBox): FracRect;

export declare interface PendingOp {
    id: number;
    op_type: PendingOpType;
    /** `cancelled` — somebody stopped it (POST /ops/{id}/cancel). */
    status: 'pending' | 'running' | 'cancelling' | 'done' | 'error' | 'cancelled';
    progress_total: number;
    progress_done: number;
    /** Running cross-storage transfer's bytes (issue #27); absent otherwise. */
    bytes_total?: number;
    bytes_done?: number;
    /** Objects a running same-storage copy/move/delete has found and finished
     *  inside its sources (the storage driver's count); absent otherwise. */
    objects_total?: number;
    objects_done?: number;
    target_path: string | null;
    source_dir: string | null;
    source_count: number;
    error_message: string | null;
    /** A failed APP job, classified by the server (lib/errorWords `jobFailure`
     *  says it); absent on copy/move/delete rows and on an older server. */
    error_code?: string;
    /** The engine a job needed and the server lacks (`error_code: engine_missing`). */
    error_engine?: string;
    /** The server's sentence for the failure, in the reader's language
     *  (backend ops/errcode.go): what lib/errorWords `opFailure` shows. */
    error_text?: string;
    cancellable: boolean;
    started_at: string | null;
    finished_at: string | null;
    created_at: string | null;
    plugin?: string;
    action?: string;
    /** The action's label in the caller's locale — the tray's row title. */
    label?: string;
    /** The last `job_progress` message. */
    message?: string;
    /** Where a trash job (restore, permanent delete, "empty the trash") stands,
     *  said by the server in the reader's language (0.54, findings A4/A15):
     *  what the explorer says when the job ends. Absent on other rows. */
    summary?: string;
    /** Files the job committed, once finished. */
    outputs?: PendingOpOutput[];
    /**
     * Where the FINISHED job sends the person who queued it: one of its outputs
     * and the app's own screen to start there (the job result's `surface.open`,
     * docs/APP-PLUGINS-API.md → Ops rows). Absent while it runs, after it
     * failed, and on every row whose app asked for nothing.
     *
     * ⚠ Followed only by the screen that queued the job (PluginPageView, the
     * explorer's own registered jobs): an administrator's list carries other
     * people's rows too, and their jobs must not move this person's screen.
     */
    open?: SurfaceOpenRequest;
}

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

/** One produced file of a finished plugin job, as an adapter-qualified path. */
export declare interface PendingOpOutput {
    path: string;
}

/**
 * The queue kinds this package knows by name. A server may emit others (an
 * app-plugin job is `plugin-action` on the wire and `plugin` here); anything
 * unknown is carried through verbatim rather than being read as a delete.
 */
export declare type PendingOpType = 'copy' | 'move' | 'delete' | 'plugin' | 'trash-empty' | (string & {});

/**
 * 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}`;

export declare interface PeoplePickerNodeProps {
    value?: PluginPerson[];
    multi?: boolean;
    allow_external?: boolean;
}

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

/** The person's own default, as stored. Reactive. */
export declare function personFolderDefault(): FolderViewDefault;

/**
 * The letter for a person's avatar circle: the first character of their name
 * — a whole character (an emoji or an astral letter is a surrogate PAIR, and
 * one half of it prints as �), upper-cased in the viewer's language (Turkish
 * `i` → `İ`, never `I`). '' when there is no name; the caller draws a glyph.
 */
export declare function personInitial(p: PersonLike | null | undefined, tag?: string): string;

/**
 * personName — how filex names a person on screen. ONE rule, every surface.
 *
 * ⚠⚠ QA, 2026-09-21: one administrator was "admin2" in the explorer's Owner
 * column, "admin@local" in notifications, the permissions panel and the admin
 * tables, and a full name on signatures. Each place had its own chain —
 * display name → username → e-mail (the Owner column, on the server), display
 * name → e-mail (the share dialog, the details panel, the admin header),
 * display name → e-mail local part (the presence strip). One chain now:
 *
 *   the name the server already worked out (`name` — a row's `owner_name`,
 *   `user_name`, `creator_name`: model.PersonLabel on the server, the same
 *   rule) → the display name → the username → the e-mail address.
 *
 * The server's twin is `model.PersonLabel` (backend/internal/model/user.go);
 * web/tests/lib/personName.test.ts and the Go test hold both to the same
 * cases. docs/CONTRIBUTING.md → "A person is named one way". The e-mail is a
 * second line or a tooltip where it helps — never the name while a name exists.
 */
export declare interface PersonLike {
    /** A label the server already resolved by the same rule. */
    name?: string | null;
    display_name?: string | null;
    username?: string | null;
    email?: string | null;
}

export declare function personName(p: PersonLike | null | undefined): string;

/** The fields of `GET /api/files/quota/me` (quota.Snapshot) the line reads. */
export declare interface PersonUsage {
    used_bytes: number;
    quota_bytes: number;
    unlimited?: boolean;
}

/** The app interface that opens the file; null is filex's own viewer, or
 *  ONLYOFFICE (pickOpenHandler tells the two apart). */
export declare function pickAppViewer(views: readonly PluginViewRow[], node: NodeLike, choice?: string | null, rules?: Readonly<Record<string, OpenRule>> | null, personal?: string | null, opts?: OpenHandlerOptions | null): PluginViewRow | null;

/** The handler that opens the file (see the header for the rule). */
export declare function pickOpenHandler(views: readonly PluginViewRow[], node: NodeLike, choice?: string | null, rules?: Readonly<Record<string, OpenRule>> | null, personal?: string | null, opts?: OpenHandlerOptions | null): OpenHandler | null;

export declare type PinFailure = '' | 'wrong' | 'locked';

export declare interface PinInputNodeProps {
    /** 4..8, default 6. */
    length?: number;
}

/** A box in CSS pixels on a drawn page. */
declare interface PixelRect {
    left: number;
    top: number;
    width: number;
    height: number;
}

export declare function pixelToFrac(px: PixelRect, size: {
    width: number;
    height: number;
}): FracRect;

/**
 * Could this be a language tag at all? `es`, `pt-br`, `zh-hant` — yes;
 * `../etc`, `` — no. What a HELD choice has to be.
 */
export declare function plausibleLocale(raw: string | undefined | null): boolean;

export declare const PLUGIN_ACTIONS_TTL_MS: number;

/** The path segment under a mount base that a plugin page lives at. */
export declare const PLUGIN_PAGE_SEGMENT = "apps";

/** The menu key for an action row: the server's, or `plugin:<plugin>/<id>`. */
export declare function pluginActionKey(a: Pick<PluginActionRow, 'plugin' | 'id' | 'key'>): string;

/** One entry of `GET /api/files/plugins/actions` → `actions[]`. */
export declare interface PluginActionRow {
    plugin: string;
    id: string;
    /** `plugin:<plugin>/<action>` — the menu row's key. */
    key?: string;
    label: PluginText;
    icon?: string;
    applies: PluginApplies;
    /** A view id: running the action opens this surface first. */
    view?: string;
    /**
     * v2 — how `view` opens: `modal` (a dialog over the explorer) or `page`
     * (a full page in a NEW TAB, `{base}apps/{plugin}/{view}?path=…`). A
     * `page` action is not run through `…/run` at all: the tab opens on the
     * view and the job is queued from the surface's own submit.
     */
    view_placement?: 'modal' | 'page' | string;
    confirm?: PluginText | null;
    min_role?: 'viewer' | 'editor' | 'owner' | string;
    danger?: boolean;
    output_mode?: 'sibling' | 'version' | 'none' | string;
    /** The result may go into a folder the person chooses (manifest
     *  `output.elsewhere`): the action is offered on a read-only storage too,
     *  and its screen asks where the result should go. */
    output_elsewhere?: boolean;
    /**
     * The server's answer to "is this action offered on a file of a read-only
     * storage?" — false where a menu click there would be refused (it writes
     * its result beside the file, and does not open a screen that asks where
     * else to put it). Always sent since 0.54; the menu reads it as it comes
     * (lib/pluginMenu).
     */
    read_only_ok?: boolean;
    /**
     * What the action would ALSO be offered on once a requirement the server
     * lacks is met — sent to administrators only. The menu draws each as a
     * greyed row that says what is missing (lib/pluginMenu).
     */
    gated?: PluginGatedRule[];
    /**
     * v4 — the action opens the app's OWN interface (its view has a `ui`
     * file): the explorer draws `AppFrame`, nothing is run on the server.
     */
    ui?: PluginUIRef;
}

/** The action rows whose rule accepts this selection. */
export declare function pluginActionsFor(actions: readonly PluginActionRow[], selection: readonly AppliesNodeLike[]): PluginActionRow[];

export declare interface PluginActionsResponse {
    actions: PluginActionRow[];
    views: PluginViewRow[];
    /** 0.50 - the open rules, by kind (a file name's extension, lower-case,
     *  no dot). A kind without one keeps the default order: the apps' viewers
     *  in the list's order, then filex's own. lib/appViewer applies them. */
    open_rules?: Record<string, OpenRule>;
}

export declare type PluginActionsStore = ReturnType<typeof usePluginActions>;

/** Which selections an action or view is offered for (wire.Applies). */
export declare interface PluginApplies {
    /** file | dir | any — the server treats an absent kind as `file`. */
    kind?: 'file' | 'dir' | 'any' | string;
    /** Lower-case, no dot. */
    ext?: string[];
    /** Exact, or a prefix glob such as `image/*`. */
    mime?: string[];
    multi?: boolean;
    min?: number;
    max?: number;
    /**
     * v2 — state-aware rows. `state` narrows the offer to files on which THIS
     * action's plugin keeps at least one of the named keys, `no_state` to
     * files that carry none of them. Listings expose the keys as
     * `app_state: ["<plugin>:<key>"]`, so a client matching this rule strips
     * the ROW'S OWN plugin prefix first (lib/pluginApplies). A signing app
     * offers "Sign" only where `pending` is set and "Request signatures" only
     * where it is not — both in the same menu.
     */
    state?: string[];
    no_state?: string[];
    /**
     * The flow the action starts ends in writing the file, although its own
     * output is `none` ("Request signatures"): filex does not offer it where
     * the file cannot be written (a read-only storage), exactly as it does not
     * offer an action whose output writes.
     */
    writable?: boolean;
}

/**
 * v3 — "that other field holds one of these values" (wire.Condition).
 *
 * Carried by `show_when` (the field is not drawn until the condition holds)
 * and `required_when` (the field is required only then). An empty `equals`
 * means "holds anything at all", which is how a field is made to depend on
 * another one merely having been answered.
 */
declare interface PluginCondition {
    key: string;
    equals?: string[];
}

/**
 * A form field — the storage descriptor field (`types/Connections.StorageField`)
 * as a plugin declares it: `label` / `help` may be Text, `i18n_key` is absent.
 *
 * ⚠ v3 removed `advanced`. A surface has no collapsed section any more: a
 * field that matters is on the step, and one that does not is not in the
 * manifest. An older plugin's `advanced` is ignored, not obeyed.
 */
export declare interface PluginField {
    key: string;
    type?: 'string' | 'int' | 'bool' | 'password' | 'select' | string;
    label?: PluginText | string;
    help?: PluginText | string;
    required?: boolean;
    secret?: boolean;
    default?: unknown;
    placeholder?: PluginText | string;
    options?: Array<{
        value: string;
        label?: PluginText | string;
    }>;
    min?: number;
    max?: number;
    multiline?: boolean;
    monospace?: boolean;
    /** v3 — a `select` that takes several of its options; the value is then a list. */
    multi?: boolean;
    /**
     * v3 — how a `bool` is drawn (wire.Field.Style): `choice` for a decision
     * the person must READ before answering (two buttons, Yes / No), `switch`
     * for an on/off setting they flip in passing (a checkbox).
     *
     * ⚠ Empty is not `switch`: it leaves the answer to the guess in
     * `lib/surfaceValues.boolIsDecision`, which is exactly why the contract
     * says to state it when the answer matters. A `select` ignores `style`
     * entirely — a surface has no dropdown for it to fall back to.
     */
    style?: 'switch' | 'choice' | string;
    /** v3 — hide the field until the condition holds; a hidden value is never sent. */
    show_when?: PluginCondition | null;
    /** v3 — require the field only while the condition holds. */
    required_when?: PluginCondition | null;
}

/** One "offered once X is there" part of an action's rule. */
export declare interface PluginGatedRule {
    ext?: string[];
    /** `engine`: a program to install; `office` (0.50): the office engine, a
     *  document server to connect; anything else: said as "not available". */
    needs: {
        kind: 'engine' | 'office' | string;
        id: string;
        name: string;
    };
}

/**
 * The app's own words for THIS reader and nobody else: the requested
 * language, or its base language (`pt` answers `pt-br`), and otherwise ''.
 *
 * Unlike `labelOf` it does NOT fall back to English — which is the whole
 * point of `appTextOr` below.
 */
export declare function pluginLabelIn(text: PluginText | string | null | undefined, locale: string): string;

/** The text for `locale`, falling back to `en`, then to any non-empty value. */
export declare function pluginLabelOf(text: PluginText | string | null | undefined, locale: string): string;

declare interface PluginMenuContext {
    locale: string;
    /** The trash view is open — plugins never run on trashed rows. */
    trash?: boolean;
    /** Inside an E2E-encrypted folder — the server would only see ciphertext. */
    e2e?: boolean;
    /**
     * The selection sits on a read-only storage. An action the server says it
     * would refuse there (`read_only_ok: false` on its row) is then not
     * offered.
     */
    readOnly?: boolean;
    /**
     * The caller's level on one selected row (`none` | `viewer` | `editor` |
     * `owner`), as the explorer's own write gate reads it (`rowPerm`). An
     * action the level cannot run is not offered — see `pluginActionNeed`.
     * Omitted, or any other answer (`''`, undefined: no ACL on that storage),
     * leaves the row ungated; the server enforces either way.
     */
    permOf?: (node: PluginMenuNode) => string | undefined;
    /** Which manifest icon names have a glyph; others fall back to `plugin`. */
    hasIcon?: (name: string) => boolean;
    /**
     * The sentence for a greyed row (an action's `gated` rule): what the server
     * lacks, in the reader's language. Absent, gated rows are not drawn.
     */
    needWords?: (need: PluginGatedRule['needs']) => string;
}

/** What the menu reads of a selected row. */
declare type PluginMenuNode = AppliesNodeLike & {
    e2e?: boolean;
    mime_type?: string | null;
    /** The app holding the file read-only, if one does (listing `lock`). */
    lock?: {
        plugin?: string;
    } | null;
};

/** The `ContextAction` fields a plugin row fills (the menu's own type owns the rest). */
declare interface PluginMenuRow {
    key: string;
    label: string;
    icon?: string;
    danger?: boolean;
    divider?: boolean;
    /** Greyed: offered once something the server lacks is there (`title` says what). */
    disabled?: boolean;
    title?: string;
}

/**
 * Menu rows for a selection, or `[]`.
 *
 * ONE GROUP PER APP, each behind its own divider. The first divider keeps its
 * old key, `sep-plugins`, so the block still reads as its own group under
 * Tags; every further app opens with `sep-plugin:<plugin>`.
 *
 * ⚠⚠ Why per app and not one block. The owner, 2026-09-21, looking at a PDF's
 * right-click menu with the converter and the signing app both installed:
 * "dönüştür ve imzalama pluginlerinin menüleri — yani her plugin'in menüleri —
 * arasına çizgi çekelim". Eight rows from two apps in one undivided run read
 * as one app's vocabulary, and "Convert to DOCX" sitting directly above
 * "Request signatures" invited the question of which app would do what. The
 * divider is the menu's own mechanism (`ContextAction.divider`), so the right
 * click, the selection bar's "⋯" and the ⋮ all draw the same lines, and
 * `ContextMenu` still collapses a divider that ends up leading, trailing or
 * doubled.
 *
 * ⚠ Grouped by `plugin`, in the order each app's FIRST row arrived — not
 * alphabetically and not by re-sorting the rows. The server lists an app's
 * actions in manifest order and the app author chose that order; a stable
 * grouping keeps it inside each app and only pulls apart rows that were
 * interleaved (which the server does not do today, but a grouping that
 * depended on it would break silently the day it did).
 */
export declare function pluginMenuRows(actions: readonly PluginActionRow[], selection: readonly PluginMenuNode[], ctx: PluginMenuContext): PluginMenuRow[];

/** `apps/sign/wizard?path=docs%3A%2F%2Fnda.pdf` — no leading slash. */
export declare function pluginPagePath(target: PluginPageTarget): string;

export declare interface PluginPageTarget {
    plugin: string;
    view: string;
    /** Adapter-qualified path of the row the action was invoked on. */
    path?: string;
}

/**
 * The full address, given the base the SPA is mounted at (`/admin/`,
 * `/drive/`, `https://fm.example.com/admin/` — with or without its trailing
 * slash). An empty base yields a root-relative `/apps/…`, which is right for
 * a host that serves the SPA at the root and wrong for one that does not —
 * hence the config field rather than a guess.
 */
export declare function pluginPageUrl(base: string | undefined | null, target: PluginPageTarget): string;

export declare const PluginPageView: DefineComponent<__VLS_Props_30, {
reload: typeof load;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
section: (id: string, how?: {
replace?: boolean;
} | undefined) => any;
op: (op: Record<string, unknown>) => any;
}, string, PublicProps, Readonly<__VLS_Props_30> & Readonly<{
onSection?: ((id: string, how?: {
replace?: boolean;
} | undefined) => any) | undefined;
onOp?: ((op: Record<string, unknown>) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

/** One person in a `people-picker` value — and one row of the users lookup. */
export declare interface PluginPerson {
    email: string;
    user_id?: number;
    name?: string;
}

/**
 * What `POST …/run` (and a view event that enqueued a job) answers with. The
 * ops row is the raw server shape; `usePendingOps.register` normalises it.
 */
export declare type PluginRunResult = {
    op: Record<string, unknown>;
    job_id?: string;
    surface?: undefined;
} | {
    surface: PluginSurface;
    op?: undefined;
};

/** A declarative screen (wire.Surface). Drawn only by filex's own components. */
export declare interface PluginSurface {
    title?: PluginText;
    size?: string;
    state?: Record<string, unknown>;
    nodes: SurfaceNode[];
    actions?: SurfaceAction[];
    toast?: PluginText;
    done?: boolean;
    job?: SurfaceJobRequest | null;
    errors?: Record<string, PluginText>;
    /**
     * v3 §3.0 — send the person to a FILE, and start a screen on it.
     *
     * A surface runs on the file it was opened on, so an app's home screen
     * could list documents and then do nothing when a row was clicked. The
     * client navigates (`lib/surfaceOpen`); with `done: true` the screen is
     * closed first and then the navigation happens.
     */
    open?: SurfaceOpenRequest | null;
    /**
     * A home page's MENU: one entry per section, drawn by the frame
     * (`SurfaceSections`), and `section` — which one this surface is.
     *
     * ⚠ The frame and not a node, because only the frame owns the address
     * bar: it keeps the open section in its URL (`?section=`), so the
     * browser's Back walks the sections and a link — a notification's —
     * lands on the right one (the owner, 2026-09-21).
     */
    sections?: SurfaceSection[];
    section?: string;
}

export declare interface PluginSurfaceEvents {
    /** The server enqueued a job: the raw ops row. */
    onOp: (op: Record<string, unknown>) => void;
    /** The conversation is over (`done`, or after `{op}`). */
    onDone: () => void;
    onToast: (message: string) => void;
    /**
     * v3 §3.0 — the answer says "go to this file" (`lib/surfaceOpen`).
     *
     * ⚠ Raised AFTER `onDone` when the answer also carries `done: true`: the
     * screen that asked for the navigation is closed first, or the person
     * arrives at the new one with the old one still over it.
     *
     * ⚠ A frame with nowhere to navigate (a public page has no explorer
     * behind it) simply does not pass this in, and the request is dropped.
     */
    onOpen?: (req: SurfaceOpenRequest) => void;
}

export declare interface PluginSurfaceHost {
    api: Pick<FileApi, 'pluginViewEvent'>;
    plugin: string;
    view: string;
    /** Adapter-qualified path the view was opened on — echoed on every event. */
    path?: () => string | undefined;
    /**
     * Every row the view was opened on (a selection) — echoed on every event
     * as `paths`, beside `path`. Absent or empty for a frame opened on one
     * row or on none (a deep link, a home page, the inspector, a public page),
     * which then sends `path` alone, exactly as before.
     */
    paths?: () => readonly string[] | undefined;
    locale: () => string;
    /** The words for an answer without a surface. */
    errorText: () => string;
}

export declare type PluginSurfaceStore = ReturnType<typeof usePluginSurface>;

/**
 * App-plugin wire shapes — the TypeScript mirror of
 * `backend/pkg/pluginkit/wire/wire.go` for the parts a browser sees.
 *
 * ⚠ Mirror, not a second design. A field lives here because it lives in
 * wire.go under the same JSON name; when the Go side grows one, add it here
 * with the same spelling. The HTTP surface around these is described in
 * docs/APP-PLUGINS-API.md.
 */
/** A label in one or more languages. `en` is required; others fall back to it. */
export declare type PluginText = Record<string, string>;

/**
 * An app's text where FILEX HAS WORDS OF ITS OWN for the same thing — a
 * caption an app may override, an empty state, a progress line.
 *
 * ⚠⚠ THE ORDER IS THE WHOLE POINT. The obvious spelling,
 * `labelOf(appText, locale) || t(key)`, reads as "the app first, filex if the
 * app said nothing" — but `labelOf` falls back to ENGLISH, and English is
 * truthy, so the host string is unreachable for every reader whose language
 * the app does not speak. Measured in v0.43.0 on the signing app's date box:
 * an app shipping en/tr/es/de/fr, a reader in Arabic, a language pack holding
 * filex's own Arabic for those very captions — and three English words in the
 * middle of an Arabic screen, because the app's English won.
 *
 * So: the app's words for this reader, then FILEX's words, and only then
 * whatever other language the app has — the last resort, and labelled as one.
 *
 * ⚠ This is for a host string that TRANSLATES THE SAME THING. Where the host
 * string is a generic stand-in for something the app NAMES (an action's
 * label falling back to "Confirm"), the app's own name in another language
 * says more than filex's placeholder, and `labelOf(…) || t(…)` is right.
 */
export declare function pluginTextOr(text: PluginText | string | null | undefined, locale: string, host: () => string): string;

/**
 * How an app's own interface is opened (docs/APP-PLUGINS-API.md → An app's own
 * interface). `url` is relative to the server's root unless interfaces have an
 * origin of their own; the client joins it with its API base.
 */
declare interface PluginUIRef {
    url: string;
    /** What the app was granted — what its bridge calls may do. */
    grants: string[];
    /** The app has a module: `engine.call` and `job.submit` answer. */
    engine: boolean;
    version: string;
}

/** `GET /api/files/plugins/users?plugin=<name>&q=` — docs "Frontend needs (M2)". */
export declare interface PluginUsersResponse {
    users: PluginPerson[];
}

/** Body of `POST …/run` and `POST …/views/{plugin}/{view}/event`. */
export declare interface PluginViewEventBody {
    /** Adapter-qualified wire path of the row the view was opened on. */
    path?: string;
    /**
     * Every row the view was opened on, adapter-qualified, in selection order.
     *
     * ⚠⚠ Sent on EVERY event of a screen opened on a selection, not only the
     * first: the server builds the event's inputs from it (and falls back to
     * `path` only when it is absent), so a conversation that echoed `path`
     * alone shrank to the first file after the opening screen — the second
     * screen said "a.txt" where the first said "3 files", and the job its
     * submit queued ran on one file (#64). The server re-checks each path for
     * the person asking; this is a report of the selection, not a grant.
     */
    paths?: string[];
    storage_id?: number;
    state?: Record<string, unknown>;
    event: 'open' | 'change' | 'submit' | 'action';
    action_id?: string;
    data?: PluginViewEventData;
}

/** `data` of a view event: every node with an id contributes `values[id]`. */
export declare interface PluginViewEventData {
    values?: Record<string, unknown>;
    /** `list` row actions only. */
    row_id?: string;
    [k: string]: unknown;
}

/** One entry of `GET /api/files/plugins/actions` → `views[]`. */
export declare interface PluginViewRow {
    plugin: string;
    id: string;
    placement: 'modal' | 'inspector' | 'home' | 'viewer' | string;
    label: PluginText;
    applies?: PluginApplies;
    icon?: string;
    size?: string;
    /** v4 — the view is the app's own interface (`viewer` views always are). */
    ui?: PluginUIRef;
}

/**
 * The categories `lang` HAS, in CLDR order: every category some whole number
 * from 0 to 999 falls in, plus `other` always.
 *
 * ⚠⚠ NOT `resolvedOptions().pluralCategories`. Current ICU lists `many` for
 * Spanish, French, Italian, Portuguese and Catalan — a category only exact
 * millions and compact numbers reach (`select(1000000)` is 'many') — so
 * Spanish would have three categories, and a Spanish admin string written in
 * the classic three forms `zero | one | other` would be read in CLDR order
 * (`one | many | other`): 1 would pick the "zero" form. Counting what whole
 * numbers people actually see select gives es/fr/it/pt `one | other`, Russian
 * `one | few | many | other`, Arabic all six, Japanese `other`, Latvian
 * `zero | one | other`, Romanian `one | few | other`.
 *
 * ⚠ The SAME definition as the pack validator (scripts/i18n-validate.mjs) and
 * the server (Go, golang.org/x/text CLDR tables, sampled 0 … 999 + other). A
 * third definition here would pass a pack there that renders wrong here.
 *
 * ⚠ In CLDR order, whatever order the runtime answers in: the admin panel
 * maps a message's forms to categories BY POSITION — an unsorted list would
 * hand Arabic's "few" form to the number 0.
 *
 * Cached: a thousand `select` calls, once per language per page.
 */
export declare function pluralCategories(lang: string | undefined | null): readonly string[];

export declare type PluralCategory = (typeof CLDR_ORDER)[number];

/**
 * The category `lang` puts the number `n` in — `'one'`, `'few'`, `'other'`…
 *
 * ⚠ The absolute value: "−1 day" agrees like "1 day", and `select` has no
 * opinion about a sign. A count that is not a finite number (a formatted
 * "1,234" that `Number()` could not read) is `other`, the plain form, which
 * is what the single `_one` rule this replaced did with it too.
 */
export declare function pluralCategory(lang: string | undefined | null, n: number): string;

/**
 * Which of a vue-i18n message's `|`-separated forms `lang` reads for `choice`
 * — a vue-i18n `pluralRules` entry, `(choice, choicesLength) => index`.
 *
 *   - as many forms as the language has categories (more than one, and
 *     "has" as `pluralCategories` counts them): those categories, in CLDR
 *     order — Arabic `zero | one | two | few | many | other`, Russian
 *     `one | few | many | other`, Romanian `one | few | other`;
 *   - one form: that form (a language that does not inflect);
 *   - two: `one | other`;
 *   - three: the classic `zero | one | other`;
 *   - anything else: the last form, which is the `other` one.
 *
 * ⚠ The first rule outranks the next three, so a language with exactly three
 * categories (Latvian, Romanian) writes three forms in CLDR order, not as
 * `zero | one | other`. Spanish, French, Italian and Portuguese are NOT among
 * them — see `pluralCategories` on the `many` ICU lists for round millions —
 * so their three-form strings stay classic.
 *
 * ⚠ English and Turkish are not routed here — they keep vue-i18n's own rule,
 * which the shipped catalogues were written against (web/src/i18n).
 */
export declare function pluralChoiceIndex(lang: string | undefined | null, choice: number, choicesLength: number): number;

/**
 * Every key the account document carries.
 *
 * ⚠⚠ A key the client does not list here is DROPPED on the next write:
 * `sanitize` keeps only these, and `PUT` replaces the whole document. So a
 * preference that is not a look (the tour) still has to be named here, or the
 * first palette change after it was stored would erase it.
 */
export declare const PREF_KEYS: readonly PrefKey[];

/**
 * The localStorage mirror's key per preference.
 *
 * ⚠⚠ These are the names the surfaces ALREADY read at first paint
 * (`web/src/lib/theme`, `lib/themes.THEME_LS_KEY`, `lib/density`,
 * `web/src/i18n`). Inventing new ones here would have left four first-paint
 * readers looking at keys nobody writes — the preference would work, and
 * the window would flash on every load, which is the failure this module is
 * supposed to remove.
 */
export declare const PREF_LS_KEYS: Record<LookKey, string>;

export declare type PrefKey = keyof UiPrefs;

/** How long a change waits for the next one before it is sent. */
export declare const PREFS_PUT_DEBOUNCE_MS = 400;

export declare interface PrefsConfig {
    /** `web`, `desktop`, or whatever a new surface calls itself. */
    surface: string;
    /** API origin; empty = same origin. Unset: the base path this document was
     *  served under (lib/appBase) — `''` at the root. */
    base?: string;
    /** Per-call auth, for a host that does not ride on cookies (the desktop app). */
    headers?: () => Promise<Record<string, string>> | Record<string, string>;
    fetchImpl?: typeof fetch;
    /**
     * ⚠⚠ Does this host have a SIGNED-OUT state at all?
     *
     * The filex SPA does: it draws a sign-in page, and the rule this flag turns
     * on is the owner's (`SESSION_LS_KEY` above) — with nobody signed in, the
     * palette and the light/dark mode in this browser belong to somebody else
     * and are not read.
     *
     * Most hosts do NOT. An explorer embedded in work.example.com or in the fishapp
     * is mounted inside a page the host already authenticated; the desktop app
     * is past its pairing screen. They never call `rememberSession`, they have
     * no `/api/auth/me` to call, and gating them would mean the palette a person
     * picked inside the embed silently stopped applying on the next load — a
     * regression, not a fix.
     *
     * ⚠ This is a fact about the HOST, declared once beside `surface` and
     * `base`, not a branch on which surface is running: there is exactly one
     * mechanism and every caller goes through it. Default OFF, so a host that
     * says nothing keeps the behaviour it has always had.
     */
    sessionAware?: boolean;
}

/**
 * Did the host wire the account's document at all? An explorer embedded in
 * another product never calls `configurePrefs`, and for it there is no account
 * copy to wait for — only this browser's.
 */
export declare function prefsConfigured(): boolean;

export declare function prefsHydrated(): boolean;

/** See `settled`. */
export declare function prefsSettled(): boolean;

/**
 * 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, {} & {
close: () => any;
nav: (delta: number) => any;
saved: (saved: {
path: string;
size?: number;
}) => any;
starred: (value: boolean) => any;
share: (file: FileNode) => any;
op: (op: Record<string, unknown>) => any;
toast: (message: string) => any;
"draft-saved": (saved: SavedDraft) => any;
"draft-discarded": () => any;
"office-edited": (edited: boolean) => any;
"outside-resolved": (answer: OutsideAnswer) => any;
}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
onClose?: (() => any) | undefined;
onNav?: ((delta: number) => any) | undefined;
onSaved?: ((saved: {
path: string;
size?: number;
}) => any) | undefined;
onStarred?: ((value: boolean) => any) | undefined;
onShare?: ((file: FileNode) => any) | undefined;
onOp?: ((op: Record<string, unknown>) => any) | undefined;
onToast?: ((message: string) => any) | undefined;
"onDraft-saved"?: ((saved: SavedDraft) => any) | undefined;
"onDraft-discarded"?: (() => any) | undefined;
"onOffice-edited"?: ((edited: boolean) => any) | undefined;
"onOutside-resolved"?: ((answer: OutsideAnswer) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
viewerEl: HTMLDivElement;
imgEl: HTMLImageElement;
markdownEl: HTMLDivElement;
appFrameRef: CreateComponentPublicInstanceWithMixins<Readonly<{
api: FileApi;
app: string;
version?: string;
view: string;
placement: "modal" | "page" | "inspector" | "home" | "viewer";
ui: PluginUIRef;
files?: AppFrameFile[];
savePath?: string;
readOnly?: boolean;
locale: LocaleCode;
theme?: ThemeMode;
userName?: string;
title?: string;
storages?: string[];
startAt?: string;
}> & Readonly<{
onClose?: (() => any) | undefined;
onTitle?: ((text: string) => any) | undefined;
onSaved?: ((r: {
path: string;
size: number;
index: number;
}) => any) | undefined;
onOp?: ((op: Record<string, unknown>) => any) | undefined;
onToast?: ((t: {
text: string;
tone: NonNullable<ToastParams["tone"]>;
}) => any) | undefined;
onConnected?: (() => any) | undefined;
onDirty?: ((dirty: boolean) => any) | undefined;
"onSaved-as"?: ((r: {
path: string;
name: string;
size: number;
}) => any) | undefined;
}>, {
requestSave: () => Promise<boolean>;
confirmClose: () => Promise<boolean>;
notifyUpdated: (version: string) => void;
notifyClosing: () => void;
reload: () => void;
reloadNewer: () => Promise<void>;
connected: Ref<boolean, boolean>;
dirty: Ref<boolean, boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
title: (text: string) => any;
saved: (r: {
path: string;
size: number;
index: number;
}) => any;
op: (op: Record<string, unknown>) => any;
toast: (t: {
text: string;
tone: NonNullable<ToastParams["tone"]>;
}) => any;
connected: () => any;
dirty: (dirty: boolean) => any;
"saved-as": (r: {
path: string;
name: string;
size: number;
}) => any;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
host: HTMLDivElement;
}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
api: FileApi;
app: string;
version?: string;
view: string;
placement: "modal" | "page" | "inspector" | "home" | "viewer";
ui: PluginUIRef;
files?: AppFrameFile[];
savePath?: string;
readOnly?: boolean;
locale: LocaleCode;
theme?: ThemeMode;
userName?: string;
title?: string;
storages?: string[];
startAt?: string;
}> & Readonly<{
onClose?: (() => any) | undefined;
onTitle?: ((text: string) => any) | undefined;
onSaved?: ((r: {
path: string;
size: number;
index: number;
}) => any) | undefined;
onOp?: ((op: Record<string, unknown>) => any) | undefined;
onToast?: ((t: {
text: string;
tone: NonNullable<ToastParams["tone"]>;
}) => any) | undefined;
onConnected?: (() => any) | undefined;
onDirty?: ((dirty: boolean) => any) | undefined;
"onSaved-as"?: ((r: {
path: string;
name: string;
size: number;
}) => any) | undefined;
}>, {
requestSave: () => Promise<boolean>;
confirmClose: () => Promise<boolean>;
notifyUpdated: (version: string) => void;
notifyClosing: () => void;
reload: () => void;
reloadNewer: () => Promise<void>;
connected: Ref<boolean, boolean>;
dirty: Ref<boolean, boolean>;
}, {}, {}, {}, {}> | null;
monacoEl: HTMLDivElement;
officeEl: HTMLDivElement;
}, any>;

export declare interface PreviewNodeProps {
    /** Adapter-qualified path of a storage file. */
    path?: string;
    /** An exposed copy on a public page (`pub:N`), resolved through the host's `fileUrl`. */
    ref?: string;
}

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

/** The software's name, as every version line spells it. */
export declare const PRODUCT_NAME = "filex";

export declare const ProductVersion: DefineComponent<__VLS_Props_34, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_34> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** `filex 0.43.0` from the server's `release`, or '' while it is not known. */
export declare function productVersionLine(release: string | null | undefined): string;

export declare interface ProgressNodeProps {
    /** 0..100, or null for indeterminate. */
    value: number | null;
    label?: PluginText | string;
}

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[];
}

/** Hand the table to the shell and its bodies. */
export declare function providePublicText(src: PublicTextSource): void;

/** Called once by a host, in its root component's setup. */
export declare function provideTableEnv(env: TableEnv): void;

/**
 * The entries as they are drawn: sections with no item dropped, then entries
 * with no section dropped. A plain-link entry stays as it is.
 */
export declare function pruneMegaMenu(entries: MegaMenuEntry[]): MegaMenuEntry[];

/** Drop records the server has swept (past their `expiresAt`), and records
 *  that do not say when that is. Returns what survived. */
export declare function pruneResume(store: ResumeStorage | null, now?: number): Store;

/** The share page's own ground and card. */
export declare const PUBLIC_PAGE_TOKENS: readonly ["--fe-ppage-ground-1", "--fe-ppage-ground-2", "--fe-ppage-card"];

export declare const PUBLIC_TEXT: InjectionKey<PublicTextSource>;

/** The app surface a link carries, once it is unlocked. */
export declare interface PublicApp {
    plugin: string;
    page: string;
    title?: PluginText;
    /** Copies the app exposed to this visitor (`pub:N`). */
    files?: PublicPageFile[];
}

/**
 * `GET /api/public/branding` — unauthenticated, cached.
 *
 * ⚠ Deliberately NOT the payload `/api/branding` serves: that one also
 * carries the SSO button label, which a stranger has no business receiving.
 *
 * ⚠⚠ It used to carry the operator's custom stylesheet too, and that is the
 * sentence that was wrong here for a release: the sheet left `/api/branding`
 * for `GET /api/me/custom-css` behind auth, so no anonymous surface — this
 * one included — can be handed a stylesheet that repaints a sign-in form.
 */
export declare interface PublicBranding {
    /** The instance's own name. Empty = the product's. */
    name?: string;
    logo_url?: string;
    /** `#rgb` / `#rrggbb` — becomes `--fe-primary` on the public shell. */
    accent?: string;
    footer_text?: string;
    hide_powered_by?: boolean;
    /** The appearance a visitor gets before they choose: `system` | `light` | `dark`. */
    theme?: 'system' | 'light' | 'dark' | string;
    /** The instance's own default language. */
    locale?: string;
    /** The languages the public pages can be rendered in. */
    locales?: string[];
    /**
     * The languages installed apps add (`manifest.ui_locales`): one row each —
     * `code`, `source: "plugin"`, the `plugin` that brought it, `rtl` — and NO
     * `strings`. One language's strings are `GET /api/public/ui-locales/{code}`
     * (`lib/uiLocales.ensureLocaleStrings`), fetched when it is first used.
     *
     * ⚠⚠ Typed from the SERVER's bytes, not from belief: this field was a map
     * on the wire and a list here for a whole release, and no pack's string
     * ever reached a screen. web/tests/lib/uiLocales.test.ts reads
     * backend/internal/api/handlers/testdata/wire/public-branding.json, which
     * the Go handler's own test writes.
     */
    ui_locales?: PublicLocaleOption[];
}

declare interface PublicBrandingOptions {
    /** API origin; empty = same origin. */
    base?: string;
    fetchImpl?: typeof fetch;
}

/** What a file request will accept. */
export declare interface PublicDropLimits {
    max_files?: number;
    /** Megabytes, as the server states it. */
    max_file_size_mb?: number;
    /** Lower-case extensions, no dot. Empty = anything. */
    allowed_ext?: string[];
    /** The uploader is asked for their name. */
    ask_name?: boolean;
    /** The longest name the server keeps, in characters; a longer one is
     *  refused (`name_too_long`), so the name box stops here. */
    name_max?: number;
}

/** One row of a folder share's listing, when the server sends one. */
export declare interface PublicEntry {
    name: string;
    /** Path relative to the share root, for the browse and download URLs. */
    path: string;
    is_dir: boolean;
    size?: number;
    mime?: string;
    /** Epoch seconds or milliseconds, as the rest of the wire sends them. */
    modified?: number;
    /** Where the browser downloads this entry from; built from the token when absent. */
    url?: string;
}

/** Why a link draws nothing, for a caller that logs it. */
export declare type PublicFailure = '' | 'not_found' | 'gone' | 'error';

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

/**
 * How much room an outward-facing body needs.
 *
 * ⚠ The public page has ONE look and three widths — the three the Go-rendered
 * pages had until v0.42.2 (`.card` 400px centred, the drop card 520px, and
 * `.card--folder` 880px). Which one a link gets is decided HERE, from the
 * kind the server answered with, so the page that renders a link and the
 * preview an operator is shown on the Corporate identity page cannot come to
 * different conclusions — and so that no body carries a layout of its own
 * (the whole reason the three pages drifted apart the first time).
 *
 * ⚠ Every state that is not `ready` is drawn as a `gate` whatever this says:
 * a PIN box, "this link is not available" and "thank you" are short, and the
 * shell forces it (`PublicShell.layout`).
 */
export declare type PublicLayout = 'gate' | 'form' | 'wide';

/**
 * `app` gets the wide card (a wizard with a document in it) and so does a
 * folder that has a LISTING to show; a file request gets the middle one,
 * because it is a form with labels; a single document — and anything
 * unrecognised — gets the narrow centred card, which is the one the
 * reference screen is.
 *
 * ⚠ `list` is why a folder is not simply wide. The server does not send a
 * listing for every folder share yet, and an 880px card holding a heading
 * and two buttons is a worse page than a 520px one holding the same thing.
 * It widens the moment entries arrive, which is what the old `.card--folder`
 * was for.
 */
export declare function publicLayoutFor(kind: string | null | undefined, opts?: {
    list?: boolean;
}): PublicLayout;

/**
 * What every public link answers, whatever kind it is.
 *
 * ⚠ `expired` and `revoked` are BOTH reported, and they are different facts:
 * the clock ran out, versus the link is dead for another reason (its visit
 * ceiling is spent, the app behind it was stopped, the file is gone). The
 * shell shows one sentence for both — a visitor must not be told which —
 * but the distinction is the server's to make, not the client's to lose.
 *
 * ⚠ `locked` is NOT one of them. It is the PIN gate shut after too many
 * wrong answers, and it lifts by itself.
 */
export declare interface PublicLinkBase {
    needs_pin: boolean;
    /** The longest PIN any link may carry (the server's one PIN rule); sent
     *  with a PIN-protected link so the PIN box stops where the rule does. */
    pin_max?: number;
    unlocked: boolean;
    expired?: boolean;
    revoked?: boolean;
    locked?: boolean;
    /** RFC 3339, or absent for "no expiry". */
    expires_at?: string | null;
    /** Words for the shell's header — a subject line, a file name. */
    subject?: string;
}

export declare type PublicLinkClient<T> = ReturnType<typeof publicLinkClient<T>>;

export declare function publicLinkClient<TInfo>(url: PublicRoot, opts: PublicLinkOptions): {
    /** What the link is and what the visitor may see of it. */
    info: (query?: string) => Promise<TInfo>;
    pin: (pin: string) => Promise<TInfo>;
    /**
     * The app's opening screen.
     *
     * ⚠ There is no `/view` route: an open is `POST /event
     * {"event":"open"}`, because the opening surface and every later one are
     * the same call to the app. One endpoint, one code path in the plugin.
     */
    open: () => Promise<{
        surface?: PluginSurface;
    }>;
    /** `{surface}`, or `{op}` when the server queued a job (202). */
    event: (body: Omit<PluginViewEventBody, "path" | "storage_id">) => Promise<PluginRunResult>;
    /** Where the browser loads an exposed copy from (`pub:N`). */
    fileUrl: (ref: string) => string;
    /**
     * The same copy, asked for as a DOWNLOAD — the Download button's link.
     * ⚠ Kept apart from `fileUrl` because only this one counts as a download
     * (handlers/public_api.go serveExposed): the page's own viewer loads the
     * document to SHOW it, and the owner ruled on 2026-09-21 that looking at
     * a signing link is not downloading it.
     */
    fileDownloadUrl: (ref: string) => string;
    url: PublicRoot;
};

/** A refused answer: the HTTP status and the server's `error` code. */
declare class PublicLinkError extends Error {
    status: number;
    code: string;
    constructor(status: number, code: string, message?: string);
}
export { PublicLinkError }
export { PublicLinkError as PublicPageError }

export declare interface PublicLinkOptions {
    /** API origin; empty = same origin. */
    base?: string;
    /** The visitor's language, sent as `Accept-Language` so a plugin answers in it. */
    locale: () => string;
    /** The words for an answer that carries nothing to show. */
    errorText: () => string;
    /**
     * The words for a drop that arrived but whose answer did not (a proxy gave
     * up, the connection dropped): it may well be saved. Absent: `errorText`.
     */
    unansweredText?: () => string;
    fetchImpl?: typeof fetch;
}

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

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

/**
 * The walk itself.
 *
 * `TInfo` is the shape the body needs (`PublicShareInfo`,
 * `PublicRequestInfo`); this composable only reads the four facts every
 * public link has — does it want a PIN, is it unlocked, has it a surface,
 * and is it still alive.
 */
/**
 * What `usePublicLink` hands back.
 *
 * ⚠⚠ Written out rather than inferred (`ReturnType<typeof …>`). The returned
 * object carries the surface conversation, whose own type names Vue's
 * internal ref helpers, and an inferred declaration cannot name them from
 * outside this package: `vue-tsc` failed the package build with TS2742 — "the
 * inferred type cannot be named without a reference to @vue/shared" — and the
 * published `.d.ts` was built anyway, with a type consumers could not use.
 * A written type is also the contract: adding a field here is a decision.
 */
export declare interface PublicLinkStore<TInfo extends {
    needs_pin?: boolean;
    unlocked?: boolean;
    expired?: boolean;
    revoked?: boolean;
    locked?: boolean;
}> {
    status: Ref<PublicStatus>;
    info: Ref<TInfo | null>;
    reason: Ref<PublicFailure>;
    pinFailure: Ref<PinFailure>;
    lockMessage: Ref<string>;
    pinBusy: Ref<boolean>;
    failure: Ref<string>;
    toast: Ref<string>;
    jobId: Ref<string>;
    /** The plugin surface on this link, when it carries one. */
    conv: PluginSurfaceStore;
    /** (Re-)read the link. `query` is appended verbatim (`?path=…`). */
    load: (query?: string) => Promise<void>;
    submitPin: (pin: string) => Promise<void>;
    /** Where the browser loads an exposed copy from (`pub:N`). */
    fileUrl: (ref: string) => string;
    /** The same copy as a download — the only fetch that counts as one. */
    fileDownloadUrl: (ref: string) => string;
    resolveFile: (ref: string) => {
        url: string;
        name?: string;
        mime?: string;
    };
    url: PublicRoot;
}

/**
 * One entry of the language list the interface offers.
 *
 * ⚠ The list is NOT a constant any more (v3 §5). It is the product's own
 * languages plus whatever the server adds — including a language an app
 * plugin ships (`manifest.ui_locales`), which is marked with the app it came
 * from and leaves with it. A key the extra language does not carry falls
 * back to English, exactly as a missing key always has.
 */
export declare interface PublicLocaleOption {
    /** BCP-47 primary subtag, e.g. `en`, `tr`, `ar`. */
    code: string;
    /** The language's name IN that language ("Türkçe"), not in the viewer's. */
    label?: string;
    /** `builtin` = shipped with filex; `plugin` = added by an app. */
    source?: 'builtin' | 'plugin' | string;
    /** The app that ships it, when `source` is `plugin` — shown beside the name. */
    plugin?: string;
    /**
     * That language's strings by filex's own keys — absent on the branding
     * list, present once `ensureLocaleStrings` has fetched them.
     */
    strings?: Record<string, string>;
    /**
     * Written right to left (Arabic, Hebrew, Persian, Urdu, …): the page's
     * `dir` follows (lib/direction, docs/RTL.md).
     */
    rtl?: boolean;
}

/**
 * The little a visitor learns about the thing behind a link: what it is
 * called, how big it is, what kind of thing it is. Never its path, never its
 * storage, never who owns it. Absent until the link is unlocked.
 */
export declare interface PublicNode {
    name: string;
    size?: number;
    mime?: string;
}

export declare type PublicPageClient = ReturnType<typeof publicPageClient>;

/** @deprecated Use `publicLinkClient(shareRoot(base, token), …)`. */
export declare function publicPageClient(token: string, opts: PublicPageClientOptions): {
    info: (query?: string) => Promise<PublicPageInfo>;
    pin: (pin: string) => Promise<PublicPageInfo>;
    open: () => Promise<{
        surface?: PluginSurface;
    }>;
    event: (body: Omit<PluginViewEventBody, "path" | "storage_id">) => Promise<PluginRunResult>;
    fileUrl: (ref: string) => string;
    fileDownloadUrl: (ref: string) => string;
    url: PublicRoot;
};

declare type PublicPageClientOptions = PublicLinkOptions;

declare interface PublicPageFile {
    ref: string;
    name: string;
    size?: number;
    mime?: string;
}

/** What `GET /api/p/{token}` answered before v3. `/api/p/*` is retired (it
 *  301s to `/api/public/s/{token}`); kept for the deprecated `usePublicPage`
 *  exports — new code reads `PublicShareInfo` through `usePublicShare`. */
declare interface PublicPageInfo {
    plugin: string;
    page: string;
    title: PluginText;
    subject?: string;
    requires_pin: boolean;
    unlocked: boolean;
    expires_at?: string | null;
    files: PublicPageFile[];
}

/**
 * @deprecated `/p/` is retired (v3 §1). The status names moved with the
 * walk: what used to be `'surface'` is `'ready'`, because a share's body is a
 * document or a folder at least as often as it is a plugin's screen.
 */
export declare type PublicPageStatus = PublicStatus;

export declare type PublicPageStore = ReturnType<typeof usePublicPage>;

/** The share page's three tokens for one variant: each one the theme defines,
 *  the derived one for each it does not. */
export declare function publicPageTokens(theme: ThemeDef, variant: 'light' | 'dark'): ThemeTokenMap;

/** `/api/p/{token}` and its children. */
export declare function publicPageUrl(base: string | undefined, token: string, tail?: string): string;

export declare const PublicPinGate: DefineComponent<__VLS_Props_23, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
submit: (pin: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_23> & Readonly<{
onSubmit?: ((pin: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
input: HTMLInputElement;
}, HTMLFormElement>;

export declare const PublicRequestBody: DefineComponent<__VLS_Props_25, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
files: (files: File[], name: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_25> & Readonly<{
onFiles?: ((files: File[], name: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
input: HTMLInputElement;
}, HTMLDivElement>;

/** `GET /api/public/d/{token}` — the drop box an outsider uploads into. */
export declare interface PublicRequestInfo extends PublicLinkBase {
    kind?: 'drop' | string;
    /** The destination's NAME — never its path, and never a listing. */
    folder?: string;
    /** How many files may still be dropped; null/absent = uncounted. */
    uploads_left?: number | null;
    limits?: PublicDropLimits;
}

/** Builds the addresses of one link's walk. */
export declare type PublicRoot = (tail: string) => string;

/**
 * One server sentence, filled: `{name}` placeholders replaced, the plural form
 * picked on the count. Exported for tests and for a caller outside a
 * component; components use `usePublicText().pt`.
 */
export declare function publicSentence(table: Readonly<Record<string, string>>, lang: string, key: string, vars?: Record<string, string | number>): string;

export declare const PublicShareBody: DefineComponent<__VLS_Props_24, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
navigate: (path: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_24> & Readonly<{
onNavigate?: ((path: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** `GET /api/public/s/{token}`. */
export declare interface PublicShareInfo extends PublicLinkBase {
    kind: PublicShareKind;
    /** Visits left before the link stops answering; null = uncounted. */
    visits_left?: number | null;
    node?: PublicNode | null;
    app?: PublicApp | null;
    /**
     * The item (or a folder above it) is an entry its storage could not answer
     * for (#104). The link is alive; the page says so instead of offering a
     * download that would fail, and the server refuses one with a page that
     * says the same.
     */
    unavailable?: boolean;
    /**
     * A folder share's listing.
     *
     * ⚠ Not sent today — the server answers a folder share with its NAME and
     * leaves the walking to the no-JS page. Declared because the shell draws a
     * listing the moment one arrives, and because the alternative (a second
     * browse implementation in the SPA, reading a different endpoint) is the
     * thing this round exists to stop.
     */
    entries?: PublicEntry[];
    /** The path being listed, relative to the share root. */
    path?: string;
}

/**
 * `kind` decides the BODY the shell draws and nothing else — the header,
 * the PIN gate, the language picker and the footer are the shell's.
 *
 *   file   → one document: download it
 *   folder → a folder, downloaded whole or walked
 *   app    → an app plugin's screen, drawn by SurfaceRenderer
 */
export declare type PublicShareKind = 'file' | 'folder' | 'app';

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

export declare type PublicStatus = 'loading' | 'pin'
/** The body may be drawn (a file, a folder, an upload box, a surface). */
| 'ready'
/** A surface answered `202` — the job is queued and the visitor is done. */
| 'accepted' | 'done' | 'not_found' | 'gone' | 'error';

/** `GET /api/public/strings`. */
export declare interface PublicStringsAnswer {
    lang: string;
    dir?: string;
    strings: Record<string, string>;
}

declare interface PublicTextOptions {
    /** API origin; empty = same origin. */
    base?: string;
    /** The visitor's language, as the page resolved it. */
    locale: () => string;
    fetchImpl?: typeof fetch;
}

/** What a page that owns the language hands down. */
export declare interface PublicTextSource {
    /** The table, keys without `server.public.`; empty until it arrives. */
    table: Readonly<Ref<Readonly<Record<string, string>>>>;
    /** The language the server answered the table in. */
    lang: Readonly<Ref<string>>;
    /** True once an answer (or a failure) has come back for the current language. */
    ready: Readonly<Ref<boolean>>;
}

/** One file on its way up, as the drop box shows it. */
export declare interface PublicUpload {
    name: string;
    size: number;
    /** 0..100, or -1 while the browser has not said anything yet. */
    percent: number;
    /**
     * `refused` — never sent: the link does not take it (its type, its size, one
     * file too many). Said before the transfer, not after it.
     * `saving` — every byte is sent and the server is writing it to the storage.
     * `unconfirmed` — every byte was sent, but the answer never came (a proxy
     * gave up, the connection dropped): it may well be saved.
     */
    state: 'sending' | 'saving' | 'done' | 'failed' | 'unconfirmed' | 'refused';
    error?: string;
}

/** What the person on the drop page adds to the files. */
declare interface PublicUploadOptions {
    /** Their name, when the link asks for it (`limits.ask_name`). */
    name?: string;
    /**
     * The words for a file this page will not send. Handed in by the page
     * because the page has the catalogue; the rule that decides lives in
     * `lib/dropLimits`.
     */
    refusedText?: (reason: DropRefusal) => string;
}

/**
 * The inverse of `explorerHashPath`: `#qldemo/Documents` → `qldemo://Documents`.
 *
 * ⚠⚠ It lives HERE, beside its inverse, because the two path shapes are the
 * documented trap of this module: the address bar carries `#<storage>/<folder>`
 * while rows carry `data-fe-path="<storage>://<path>"`, and hand-converting one
 * into the other is how a hash ends up naming a folder called `qldemo:`. A
 * surface that needs the qualified form of "the folder currently open" asks
 * for it rather than slicing a string.
 *
 * `''` for an empty hash. A hash naming only a storage yields `<storage>://`,
 * which is that storage's root — the shape the explorer uses for it.
 */
export declare function qualifiedFromHash(hash: string | undefined | null): string;

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

/** Reads the base from a document; `''` when it has none, or a bad one. */
export declare function readAppBase(doc?: Pick<Document, 'querySelector'> | null): string;

/**
 * Read a stored column state against the columns that exist TODAY.
 *
 * ⚠ Clamped and filtered on the way IN, not only on the way out: a width
 * stored by an older build (or hand-edited) outside today's bounds would draw
 * a column nobody can reach the edge of, and a hidden id that no longer names
 * a column would sit in the document forever. Nothing in the UI could explain
 * either, so neither is allowed through.
 */
export declare function readCols<Id extends string>(raw: unknown, specs: readonly TableColumnSpec<Id>[]): ColsState<Id>;

/**
 * Read the prefix off the front of a `.fxe` stream. The rest of the stream —
 * the body — comes back unread.
 */
export declare function readFxe(stream: ReadableStream<Uint8Array>): Promise<{
    parsed: ParsedFxe;
    body: ReadableStream<Uint8Array>;
}>;

/** Parse the operator's default — an object, or the JSON string the settings
 *  table stores. Anything unreadable is "no instance default". */
export declare function readInstanceFolderDefault(raw: unknown): InstanceFolderDefault;

export declare const RecentlyOpened: DefineComponent<__VLS_Props_15, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (message: string) => any;
open: (node: RecentNode) => any;
context: (node: RecentNode, ev: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_Props_15> & 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_44, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
}, string, PublicProps, Readonly<__VLS_Props_44> & Readonly<{
onClose?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/** The DOM element behind a template ref that may be a component (Headless UI's buttons are). */
export declare function refElement(r: unknown): HTMLElement | null;

/** Re-read the document (throttled) — when a tab comes back to the front. */
export declare function refreshViewPrefs(force?: boolean): void;

/** The `error` field of a JSON refusal body, or ''. */
export declare function refusalCode(body: string): string;

/**
 * The field a server refusal is about (`{error, message, field}` from
 * handlers/account_rules.go), so a form can put the server's sentence — it
 * is already in the reader's language — under the right box.
 */
export declare function refusalField(err: unknown): {
    field: string;
    message: string;
} | null;

/** The words for a refusal: what the server SAID (`message`), the status's
 *  words when it said nothing. */
export declare function refusalWords(status: number, body: string, locale: string | undefined): string;

/** Register a resolver; returns its unregister. */
export declare function registerE2eNameResolver(r: E2eNameResolver): () => void;

/**
 * Add (or replace) a language the server offers. `strings` absent = listed
 * only; the table is fetched when first asked for.
 *
 * ⚠ A built-in language is never replaced wholesale — a pack that ships
 * `tr` is OVERLAYING keys onto the catalogue, not taking it over, or one
 * badly-packed app could blank the interface for everybody who reads Turkish.
 */
export declare function registerLocale(opt: PublicLocaleOption): void;

export declare function registerPersonalForget(forget: () => void): void;

/**
 * A module with a per-person key of its own adds it here.
 *
 * ⚠ `lib/themes` registers `filex.thememode` this way rather than having its
 * name repeated in the list above — a second copy of a storage key is exactly
 * the drift `lib/density`' header warns about, where a rename on one side
 * leaves the other writing to a key nobody reads.
 */
export declare function registerPersonalMirror(key: string): void;

/** The same file with an updated header (a password change) keeps its keys. */
export declare function rekeyedFxeKey(key: FxeKey, header: FxeHeader): FxeKey;

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

declare function reload(): Promise<void>;

export declare function rememberedAccountTimeZone(): string;

/** How many folders are remembered — "Apply to all folders" 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 — ONLY the fields that changed.
 *
 * ⚠ The ONLY thing that creates an entry. Navigation does not (see
 * `touchFolder`), so the map is the set of folders somebody deliberately set
 * up rather than a log of everywhere they have been.
 *
 * ⚠ A patch, merged. Switching a folder to grid records `v` and nothing else,
 * so the folder's SORT still follows the default: a person who later changes
 * their default sort sees it in every folder whose sort they never touched,
 * including the ones whose view mode they did.
 */
export declare function rememberFolder(key: string, patch: Omit<FolderPrefs, 't'>): void;

/**
 * `/api/auth/me` has answered. Remember it for this browser's next first paint.
 *
 * ⚠ A hint and nothing more — it is not a credential, it grants nothing, and
 * every authenticated request still carries the HttpOnly cookie. Forging it
 * buys an attacker the wrong palette.
 */
export declare function rememberSession(present: boolean): void;

/** THE REORDER ARITHMETIC — `lib/tableColumns.reorderColumns`, re-exported. */
export declare const reorderColumns: typeof reorderColumns_2;

/**
 * THE REORDER ARITHMETIC, on its own and with no state attached.
 *
 * ⚠⚠ `to` is the index the item ENDS UP AT — equivalently, the insertion index
 * in the list with the item already taken out. The two readings coincide for
 * every `to`, and that equivalence is the whole point of writing it down:
 * every reorder bug this function exists to close was a caller mixing the two
 * index spaces. A caller that computes its target against the list WITH the
 * column still in it hands over an index one too large whenever the column
 * moves right — which is exactly how "drag one column to the right" became
 * "two columns to the right". (Owner, 2026-09-20: "bir adım ileri çekince iki
 * adım ilerliyor".)
 *
 * `from === to` is a no-op and returns a copy, so a drop on the column's own
 * place writes nothing.
 */
declare function reorderColumns_2<T>(list: readonly T[], from: number, to: number): T[];

export declare interface ReorderDrag {
    /** The row in hand (and the row a finger is holding). */
    dragKey: Ref<string | null>;
    /** Where it would land; null = nowhere new. */
    dropGap: Ref<number | null>;
    /** A drag is under way (the list wears the grabbing cursor). */
    reordering: Ref<boolean>;
    /** A finger's gesture is in progress — its long-press `contextmenu` is the gesture's, not a menu request. */
    touchActive: () => boolean;
    onPointerDown: (key: string, ev: PointerEvent) => void;
    /** Bind with `@click.capture` on the list: swallows the click a release produces. */
    onClickCapture: (ev: MouseEvent) => void;
}

export declare interface ReorderDragOptions {
    /** The rows' keys, in the order they are drawn. */
    keys: () => readonly string[];
    /** A row's element — the drop gap is measured against its box. */
    rowEl: (key: string) => Element | null | undefined;
    /** What scrolls the rows; nudged when a drag reaches its edge. */
    scroller?: () => Element | null | undefined;
    /** A finger's wait before the row can be dragged. Default: a long press. */
    touchDelayMs?: number;
    /** A release that changes the order. */
    onDrop: (key: string, gap: number) => void;
    /** A finger's long press lifted where it was. */
    onHold?: (key: string) => void;
}

/**
 * The same `.fxe` under a new header: new prefix, then the old body carried
 * over byte for byte. `oldBody` is the stream after the old prefix.
 */
export declare function replaceFxeHeader(h: FxeHeader, oldBody: ReadableStream<Uint8Array>): {
    stream: ReadableStream<Uint8Array>;
    size: number;
};

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

/** An HTTP refusal, said. `message` is the sentence; the rest is for code
 *  that branches on it and for an administrator's second line. */
export declare interface RequestFailure extends Error {
    status?: number;
    /** The refusal's own code (`{"error":"read_only"}` → `read_only`), or ''. */
    code?: string;
    /** The raw body, clipped — NEVER shown to a regular user. */
    detail?: string;
    /** Marks an Error whose `message` is already the sentence. */
    said?: true;
    /** `admin_hint` — the fix, which the SERVER sends only to a caller who can
     *  act on it (handlers/tenantown.go `callerMayConfigureInstance`). */
    hint?: string;
    /** The server's own sentence (`message`), whole: `detail` is clipped. */
    server?: string;
    /** The refusal's `reason` (`{"error":"e2e_not_allowed","reason":"policy_off"}`),
     *  kept whole. ⚠ `detail` is clipped to 300 characters, and a Go map writes
     *  its keys in order — error, message, reason — so a long `message` pushes
     *  the reason past the clip; saying the refusal again from `detail` alone
     *  (sayFailure with a `t`) would lose it. */
    reason?: string;
}

/** An HTTP refusal as an Error carrying its own sentence. */
export declare function requestFailure(status: number, body: string, locale: string | undefined): RequestFailure;

/** Did the person start this request, or did the page? */
export declare type RequestKind = 'background' | 'action';

/** `/api/public/d/{token}` — a file request. */
export declare function requestRoot(base: string | undefined, token: string): PublicRoot;

export declare function resetAllShortcuts(): void;

export declare function resetColumns(): void;

/** Forget everything. For tests, and for a surface being torn down. */
export declare function resetConnectionNotice(): void;

/** Testing seam / sign-out: back to the two we ship, list not yet known. */
export declare function resetLocales(): void;

/** Testing seam: forget the session's state. */
export declare function resetPrefs(): void;

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

/** Testing seam. */
export declare function resetTourState(): 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;

/** The plaintext of `wire` (inside the encrypted folder `root`), or null. */
export declare function resolveE2eName(wire: string, root: string): {
    name: string;
    path: string;
} | null;

declare interface ResolveEmailResponse {
    found: boolean;
    user?: {
        id: number;
        email: string;
        display_name: string;
        username?: 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;

/**
 * The folder's view, resolved: its own memory (or seed), then the defaults.
 * View mode and sort resolve independently — a folder that only remembers
 * "grid" still follows the default sort.
 */
export declare function resolveFolderView(key: string): {
    v?: ViewMode_2;
    k?: SortKey;
    d?: SortDir;
};

/**
 * 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, and a
 * language pack's own tag (`es`, `pt-br`) resolves while the pack is offered;
 * anything nothing offers falls through rather than half-rendering.
 */
export declare function resolveLocale(explicit?: LocaleCode | '' | null): LocaleCode;

/**
 * Resolve a notification's target into the place a click should land.
 *
 * ⚠ A file target resolves to its FOLDER plus a selection, never to the file
 * as a path of its own. Opening "the file" would mean guessing whether to
 * preview it, edit it or download it — three different answers for three file
 * types — where showing it in its folder is the one answer that is right for
 * every type, and is also what "reveal" means in every file manager.
 *
 * ⚠ Anything incomplete resolves to `none`, never to a partial address: a file
 * target with no storage would otherwise open whichever storage the user
 * happened to have in front of them, which is worse than not moving at all.
 */
export declare function resolveNotificationTarget(target: NotificationTarget | null | undefined): NotificationDestination;

/**
 * The session answer changed — re-decide whose look this window wears.
 *
 * ⚠⚠ Needed because the two reads above happen at MODULE LOAD, and the only
 * synchronous evidence available then is `hasSession()`'s stored hint. Two
 * things can contradict it later and both must be obeyed:
 *   • the document turns out to be a public link (`sealSessionless` in the
 *     host's boot), and
 *   • `/api/auth/me` answers "nobody" on a browser whose hint said otherwise —
 *     a session that expired, or somebody who closed the tab instead of
 *     signing out. That is the shared-machine case, and leaving it unhandled
 *     would keep the leak alive for exactly the people most likely to hit it.
 *
 * ⚠ It re-READS rather than assuming: called after a sign-in it restores the
 * person's own palette from the mirror, so the function is one answer to the
 * question, not a one-way demotion.
 *
 * ⚠ It touches no storage. Nothing here is a choice anybody made.
 */
export declare function resolveSessionLook(): void;

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

/** The server's `expires_at` (RFC 3339) as epoch ms; undefined when absent or unreadable. */
export declare function resumeExpiry(expiresAt: string | null | undefined): number | undefined;

/**
 * uploadResume — where a browser upload writes down that it is not finished.
 *
 * A staged upload survives a dropped connection because the SERVER holds the
 * bytes and can be asked for its offset. What the browser has to survive is
 * itself: a reloaded tab, a closed laptop, a crashed renderer. None of those
 * reach the server, and without a note on disk the next visit has no idea an
 * upload id ever existed — so the same 4 GB starts again at zero, which is the
 * exact complaint this work exists to answer.
 *
 * The note is deliberately small and deliberately a hint:
 *
 *   - it stores the upload id, not the bytes. localStorage cannot hold a File,
 *     and the browser will not hand a File back without a fresh user gesture.
 *     Recovery is therefore "pick the same file again and it continues", not
 *     "it silently continues" — the honest shape, and the one the platform
 *     allows.
 *   - `offset` here is never used as a resume point. It is shown to the user
 *     ("resuming at 62%") and used to decide a session is worth asking about;
 *     the byte to continue from always comes from GET /api/files/upload/{id}.
 *
 * The fingerprint pins a record to one file: name, size and lastModified. A
 * different file with the same name must not inherit the session, because
 * appending its tail to the previous head is the one way a resumable upload
 * corrupts data.
 *
 * This lives in `packages/core` because it is not browser-chrome: the web
 * explorer, the desktop app's explorer and the work.example.com / fishapp embeds all
 * mount the same component, and an upload that resumes in one of them and not
 * the others would be two products again.
 */
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;
    /**
     * When the server sweeps this upload's staging (epoch ms) - the `expires_at`
     * its `begin` answered. Past it the record is dropped. ⚠ A record without
     * one (written before 0.54, or after a `begin` that did not say) is dropped
     * too: there is no honest guess at the server's TTL.
     */
    expiresAt?: 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;
}

/**
 * Take the reader to a notification's destination, IN THIS EXPLORER: the
 * folder with the row selected (and the app screen the notice asked for), the
 * Trash view with the deleted item selected, an app's home view, or — for a
 * share — the public page in a new window. `none` goes nowhere.
 *
 * ⚠⚠ The destination comes from `resolveNotificationTarget`, the ONE resolver
 * the web bell, the browser toast and the desktop OS toast all use; this only
 * carries it out. It is exposed (and forwarded by the web component) so the
 * desktop app hands a clicked OS notification to the same code its in-window
 * bell uses, instead of re-mounting the explorer and ticking checkboxes from
 * outside.
 *
 * ⚠ The row is selected through the explorer's own selection, after the
 * listing has finished — `onOpenOpOutput`'s shape. A host that ticked the
 * row's checkbox from outside had to retry for eight seconds, because the
 * listing clears the selection when it lands and the host could not see when.
 */
declare function revealNotification(dest: NotificationDestination): Promise<boolean>;

/**
 * The key for the listing of every storage at once (the multi-storage root).
 * It is a place like any other — a person who sorts their drives by name
 * expects them to stay sorted — so it gets a key of its own rather than
 * falling through to "no folder", which would write the person's DEFAULT.
 */
export declare const ROOT_FOLDER_KEY = ".root";

declare type Rotation = 0 | 90 | 180 | 270;

export declare const RowActions: DefineComponent<__VLS_Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (key: string, action: ContextAction) => any;
}, string, PublicProps, Readonly<__VLS_Props_6> & Readonly<{
onSelect?: ((key: string, action: ContextAction) => any) | undefined;
}>, {
locale: LocaleCode;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
menu: 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;
}, any>;

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

/**
 * Does a click on this ROW go somewhere? ⚠ The SERVER says so: every row of
 * `GET /api/notifications` carries `opens` (backend notify.Opens - the one
 * rule a push's `open` follows too), so the bell, the page's pop-up and a
 * phone agree. A row from a server before 0.54 has none and is judged by its
 * target, as it always was.
 */
export declare function rowOpens(row: {
    target?: NotificationTarget | null;
    opens?: boolean | null;
}): boolean;

/**
 * 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[];

/** Is `value` acceptable under `rule`? An empty value is never wrong here — `required` is a separate question. */
export declare function ruleError(value: unknown, rule: PdfFieldRule | null): PdfRuleError;

/** `inputmode` for the on-screen keyboard a rule wants. */
export declare function ruleInputMode(rule: PdfFieldRule | null): 'text' | 'numeric' | 'email';

/** The longest string the rule allows to be typed at all. */
export declare function ruleMaxLength(rule: PdfFieldRule | null): number | undefined;

export declare function runConversion(rootWire: string, io: ConvertIo, prog: ConvertProgress, opts: ConvertOptions): Promise<void>;

/** How many characters (Unicode code points, as the server counts them). */
export declare function runeCount(s: string): number;

export declare function runNamePass(nk: E2eNameKey, rootWire: string, io: NamePassIo, prog: NamePassProgress): Promise<void>;

/**
 * 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_50, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
accessKeyID: string;
secret?: string;
endpoint: string;
pathStyle: boolean;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_50> & Readonly<{
onActive?: ((v: {
accessKeyID: string;
secret?: string;
endpoint: string;
pathStyle: boolean;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

/** A failure, said: the sentence for everybody, the raw words for an admin. */
export declare interface SaidFailure {
    text: string;
    /** Present only when the caller may administer the instance. */
    detail?: string;
}

/**
 * Two ways of spelling one row's `data-fe-path`: `docs://Documents/a.txt` and
 * `docs:///Documents/a.txt`. The Trash view builds its rows as
 * `<storage>://<original path>`, and the original path is stored with a
 * leading slash — so a reveal that compared strings exactly found nothing to
 * select there (measured 2026-09-21: trash rows read `docs:///Documents/…`).
 * Every surface that looks a row up by path compares through this.
 */
export declare function sameRowPath(a: string | null | undefined, b: string | null | undefined): boolean;

declare interface SavedDraft {
    path: string;
    name: string;
    targetDir: string;
}

/**
 * A preference changed: mirror it now, tell the account shortly.
 *
 * ⚠ The mirror is written FIRST and unconditionally. If the PUT fails, this
 * device still opens the way the person left it — which is exactly the
 * behaviour the product had before the account copy existed.
 */
export declare function savePref(key: PrefKey, value: string): void;

/**
 * Store a new order.
 *
 * `visibleKeys` is the whole list as the person now sees it; `[]` is "Reset
 * order". `visible` is the list the gesture was made on, so the entries it
 * does not draw keep their place (`mergeStorageOrder`).
 *
 * ⚠⚠ Never written to the account BEFORE the account's document has arrived
 * (the same rule `lib/tour` follows): `PUT /api/me/prefs` replaces the whole
 * document, and a write made from an empty copy would erase the person's
 * palette, density and language to record the order of their drives. Until it
 * arrives the order is on screen and in the mirror, and is sent the moment it
 * does.
 */
export declare function saveStorageOrder(visibleKeys: readonly string[], visible: readonly OrderableStorage[]): void;

/**
 * Say a caught failure.
 *
 * A `RequestFailure` already carries its sentence (`message`); anything else —
 * a thrown JS error, a library's message — is said as `fallback`, because its
 * text was written for a developer. The raw words go to the console as well,
 * where the person debugging looks for them.
 */
export declare function sayFailure(err: unknown, fallback: string, opts?: {
    callerAdmin?: boolean;
    /** The caller's own translator. A viewer knows `t` but not the locale
     *  code a refusal was built with, so the refusal is said again in its
     *  words rather than in whatever language the request was made in. */
    t?: T;
}): SaidFailure;

/**
 * How a followed scan ended: `ok`, `failed` (with the server's `error` when it
 * wrote one), `aborted` (stopped before it finished), `gone` (the storage
 * left the list), `unknown` (the list could not be read, many times over, or
 * named an end this does not know).
 */
export declare type ScanEnd = {
    status: 'ok' | 'failed' | 'aborted' | 'gone' | 'unknown';
    error?: string;
};

/** This document is a public link: the answer is no, and it is not remembered. */
export declare function sealSessionless(): void;

/** One signed-in account, as the palette's group badge draws it. */
export declare interface SearchAccount {
    /** The host's own id for the account; passed back on every hook call. */
    id: string;
    /** Short name on the badge — the server's brand name or its host. */
    label: string;
    /** Second line, quieter — typically the email signed in there. */
    detail?: string;
    /** The account's colour on the host (the rail avatar's), for the badge dot. */
    color?: string;
}

/** A search hit, addressed — the `{path, basename, type}` a listing row hands
 *  the drag-out hook, with `path` = `name://rel`. */
export declare interface SearchHitItem {
    path: string;
    basename: string;
    type: 'file' | 'dir';
}

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

export declare interface SelectOption {
    value: string | number;
    label: string;
    /** A second line under the label — what choosing this one means. */
    help?: string;
    /** Shown, greyed, and not choosable. */
    disabled?: boolean;
}

/** A number the server holds an input to; undefined when it has not said. */
export declare function serverLimit(name: keyof ServerLimits): number | undefined;

/** `capabilities.limits`: the numbers an input is held to before it is sent.
 *  The server enforces each again. */
export declare interface ServerLimits {
    /** A tag name, in characters. */
    tag_max_runes?: number;
    /** A comment, in characters. */
    comment_max_runes?: number;
    /** An encryption request's reason, in characters (the rest is cut). */
    e2e_request_reason_max_runes?: number;
    /** What one app's interface keeps for a person, as JSON bytes. */
    app_state_max_bytes?: number;
    /** One chunk of an app interface's save, in bytes. */
    app_ui_save_chunk_bytes?: number;
}

/**
 * The server's sentence in a refusal's data, isolated for the reader's
 * direction, or '' when it sent none - for a client that holds the answer's
 * data rather than its text (the admin panel's axios errors, web api/client
 * `extractError`). The explorer reads the same field through
 * `requestFailure`, so the two say one sentence about one refusal (0.54
 * audit A1: the admin panel showed the server's reason, the explorer its own
 * "You are not allowed to do this").
 */
export declare function serverSaid(data: unknown, locale: string | undefined): string;

/**
 * What to print for a refusal on a screen that used to print the server's
 * `error` field as it came (the connection panels: keys, tokens, exports).
 *
 * The server's sentence (`message`) is said as it came; an older refusal
 * that put a sentence written for a person in `error` ("public key is not a
 * valid OpenSSH key") is kept too, because the status's words would lose what
 * went wrong; plumbing and bare codes fall back to the status's words.
 *
 * ⚠ This replaced five copies of one helper that printed the field whatever
 * it held - including an environment variable to a regular user.
 */
export declare function serverWords(err: unknown, locale?: string): string;

/** The fields a `ContextAction` takes from the gate. */
declare interface ServiceGate {
    hidden?: boolean;
    disabled?: boolean;
    title?: string;
}

/**
 * ⚠⚠ WITH NO SESSION, NOTHING PERSONAL PAINTS. The owner's rule, verbatim:
 * "logoutluyken zaten seçtiğim tema değil, şirketin default, yoksa filex'in
 * default teması gelecek; tarayıcı gece modundaysa gece modunda olacak ya da
 * light mode."
 *
 * So a signed-out window wears the INSTANCE's look (`ui.default_theme`, or
 * filex's own stock palette when the operator has not set one) and follows the
 * BROWSER's `prefers-color-scheme`. The palette and the light/dark mode became
 * per-PERSON settings in v3 (migration 00047, `GET/PUT /api/me/prefs`), and a
 * person is exactly what a signed-out window does not have.
 *
 * ⚠ Measured before it was changed (2026-09-21, vitest against the shipped
 * `packages/core/dist`): with `filex.palette` = `night` and no session at all,
 * `useThemeState().themeId` came back `"night"` and `filex.thememode` = `dark`
 * came back `"dark"` — both read at MODULE LOAD, long before anything could
 * know whether a session existed. Worse, `instanceThemes.hasOwnChoice()` saw
 * the same key and suppressed the operator's own default entirely, so an
 * instance with a brand theme showed the LAST PERSON WHO SIGNED IN HERE their
 * colours on its sign-in page — and showed the next person at that shared
 * machine the previous one's taste.
 *
 * ⚠⚠ WHY A STORED HINT AND NOT THE REAL ANSWER. The real answer is
 * `/api/auth/me`, and it cannot be had at the first paint: the session cookie
 * is HttpOnly (handlers/auth.go) so JavaScript cannot see it, and the fetch
 * resolves long after the window has painted. A wrong answer is a visible bug
 * in BOTH directions — read the personal palette with no session and the leak
 * above is back; ignore it WITH a session and every single load flashes the
 * instance default on the way to the person's own palette. So this is a guess
 * that is right in the overwhelming case (this browser's last load answered
 * the same question) and is corrected within one round trip by
 * `rememberSession`, which every entry path reaches through `/api/auth/me`.
 */
export declare const SESSION_LS_KEY = "filex.session";

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

export declare function setColumnWidth(id: ColumnId, px: number): void;

/**
 * Replace the operator-defined themes. Called once at boot with the payload
 * from `/api/appearance`.
 *
 * ⚠ It also RE-RESOLVES the active selection, which is the client half of
 * "deleting a theme puts anybody using it back on the default": a browser
 * holding `custom:acme` in localStorage keeps it across the fetch, and the
 * moment a list arrives that does not contain it, the selection drops to
 * `default`.
 *
 * ⚠⚠ The correction is LOCAL — `applyStoredPalette`, never `setTheme`. Third
 * merge repair, and the most destructive of the three had it been left.
 * `setTheme` now writes the account, so correcting through it would send a
 * fact the SERVER just told us straight back to the server, as though the
 * person had chosen it. That is harmless only when the correction is right.
 * It is not always right: this browser's mirror can hold a stale id from
 * before the account was read, the two fetches have no ordering, and a
 * correction fired from that stale value would overwrite the account's real
 * choice — on every device — for a theme that was never deleted.
 *
 * Leaving the account's dead id untouched costs nothing: every read resolves
 * it to the stock palette anyway, which is the whole point of building
 * deletion as resolution rather than as a cleanup pass. The first deliberate
 * pick the person makes writes a live id over it.
 */
export declare function setCustomThemes(defs: ThemeDef[]): void;

export declare function setDensity(d: Density): void;

/** ⚠ DEPRECATED — a no-op. See `folderMemoryEnabled`. */
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;

/** Hand the module the operator's default (the transport does, on load). */
export declare function setInstanceFolderDefault(raw: unknown): void;

/** Replace the whole extra set (what one branding answer says). */
export declare function setLocales(list: PublicLocaleOption[] | undefined): void;

/**
 * Fold a branding answer's language list into the registry.
 *
 * `locales` is a list of CODES — the built-ins and whatever apps add — and
 * `ui_locales` the added ones as rows (code, app, rtl) WITHOUT strings.
 * ⚠ Registering again drops tables already fetched, so a pack that was
 * upgraded while the page was open is re-read the next time it is used
 * instead of serving yesterday's words until a reload.
 */
export declare function setLocalesFromBranding(b: PublicBranding | null | undefined, opts?: LoadLocalesOptions): PublicLocaleOption[];

export declare function setLocalPref(key: LookKey, value: string): void;

/** Keep (or, with null, forget) the person's choice for a kind. */
export declare function setOpenWithChoice(ext: string, id: string | null): void;

/**
 * Set parts of the person's default; an `undefined` or `null` field CLEARS
 * that part, so it follows the instance default again.
 *
 * ⚠ Never called by a click in a folder — only by the settings control and by
 * "Apply to all folders". That is the whole fix.
 */
export declare function setPersonFolderDefault(patch: Partial<Record<keyof FolderViewDefault, unknown>>): void;

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

/** Remember (or with null, forget) the table's sort. */
export declare function setTableSort(id: string, sort: {
    key: string;
    dir: 'asc' | 'desc';
} | null): void;

/**
 * Pick a palette.
 *
 * ⚠⚠ It is saved on the ACCOUNT, not only in this browser (`lib/prefs`).
 * A palette lived in `localStorage` alone until v3, which meant a person who
 * chose one on their laptop opened the product on their phone in the stock
 * colours and had to choose again — reported by the maintainer as exactly that. The
 * localStorage write stays as the FIRST-PAINT cache: it is what this browser
 * reads before the account's answer can arrive, so the window does not flash
 * the default on the way to the chosen one.
 */
export declare function setTheme(id: string): void;

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

/** What the server says it can do — the fields the dialog reads. */
export declare interface SettingsCapabilities {
    version?: string;
    /** The release alone (`v0.54.0`), for the version line (#211). */
    release?: string;
    /** The notification events that cannot happen here, by event: why, whether
     *  this caller could change it, and the server's sentence (#211, audit B16). */
    event_off?: Record<string, EventOff>;
    caller_admin?: boolean;
    demo_mode?: boolean;
    /** 0.51 - the document server (Default apps: whether a choice of ONLYOFFICE
     *  for a .csv is available, lib/serviceGate onlyOfficeUsable). */
    onlyoffice_url?: string | null;
    external?: {
        onlyoffice?: ExternalServiceStatus;
    };
    /** wiring:e2 vault - the server has the vault API (the idle-time row). */
    e2e_vault?: boolean;
}

/** The notification digest as the settings pane draws it (backend notify
 *  digest.go PersonDigestView). */
export declare interface SettingsNotificationDigest {
    /** How long the kinds that are not urgent are held, in minutes. */
    window_minutes: number;
    /** The kinds told at once: the person's choices over the defaults. */
    urgent_events: string[];
    /** The administrator's urgent list. */
    default_urgent: string[];
    /** Every kind a choice can be made about. */
    events: string[];
    /** The administrator alerts among them - one switch in the pane. */
    admin_events: string[];
}

/** `GET/PATCH /api/notifications/settings` — the person's own switches. */
export declare interface SettingsNotificationPrefs {
    in_app_enabled: boolean;
    muted_events: string[];
    /**
     * The digest's urgent choices: kind -> told at once? A kind it does not name
     * follows the administrator's default (`digest.default_urgent`). ⚠ Sent only
     * when an urgent switch changes: a save without it keeps what is stored, and
     * a save WITH it first tells what is held under the old choice (backend
     * handlers/notifications.go UpdateSettings).
     */
    urgent_overrides?: Record<string, boolean>;
    /** What the server says of the digest - read only; null when it is off. */
    digest?: SettingsNotificationDigest | null;
}

/** `GET /api/files/quota/me`. */
export declare interface SettingsQuota {
    used_bytes: number;
    quota_bytes: number;
    percent_used: number;
    unlimited: boolean;
}

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

/** The signed-in person, as the dialog reads and writes it. */
export declare interface SettingsUser {
    id?: number;
    email?: string | null;
    username?: string | null;
    display_name?: string | null;
    avatar_url?: string | null;
    totp_enabled?: boolean;
    role?: string | null;
    locale?: string | null;
    timezone?: string | null;
}

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

/** The same colour, `k` of the way to black (0.85 = the hover state). */
export declare function shade(hex: string, k: number): string;

/** The one line that fetches a download link's file from a terminal, as the
 *  SERVER writes it (handlers/share_command.go): it knows a folder's archive,
 *  the PIN and an S3 redirect. Shown as it is; never assembled here. */
export declare interface ShareDownloadCommand {
    /** For a POSIX shell. */
    curl: string;
    /** For Windows PowerShell 5.1 and PowerShell 7. */
    powershell: string;
}

/**
 * Where the BYTES of a share live.
 *
 * ⚠ Not under `/api/`. `/s/<token>` is the address that has always served
 * the file, and it still does — the SPA shell is what a JavaScript browser
 * gets when it NAVIGATES there (`handlers/public_shell.go`), while
 * `?download=1` and `?zip=1` are among the escapes that mean "I am asking for
 * the thing, not for a page". Building a second download route under `/api/`
 * would be a second thing to keep working.
 */
export declare function shareDownloadUrl(base: string | undefined, token: string, opts?: {
    zip?: boolean;
    path?: string;
}): string;

/**
 * The public URL of a share token. Outside the SPA — a real navigation.
 *
 * `root` is the base path the app is served under (FILEX_BASE_PATH; the web
 * passes the core's `appBase()`), `''` at the root. A parameter rather than an
 * import, because this module depends on nothing (see notificationHref).
 */
export declare function shareHref(token: string, root?: string): string;

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;
    /** On the creation answer of a DOWNLOAD link only (absent for a file
     *  request, and never in a listing - it may carry the PIN). */
    download_command?: ShareDownloadCommand | null;
}

/** POST /api/files/permissions/share-mail's answer. */
declare interface ShareMailResult {
    emailed: boolean;
    sent?: string[];
    failed?: string[];
    /** The link has a PIN the mail leaves out: the sender gives it separately. */
    pin_withheld?: boolean;
    /** The server's sentence for the composer, in their language. */
    message?: string;
}

/** The no-JS page, for whatever the shell cannot draw yet (a folder walk). */
export declare function shareNoJsUrl(base: string | undefined, token: string): string;

/** `/api/public/s/{token}` — a share (download, folder, or an app's page). */
export declare function shareRoot(base: string | undefined, token: string): PublicRoot;

/** A commit hash as git shows it short: seven characters. */
export declare function shortCommit(commit: string): 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;
    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_38, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
}, string, PublicProps, Readonly<__VLS_Props_38> & 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 function show(at?: number): Promise<void>;

/** Handwriting first, formal last — the order the picker draws. */
export declare const SIGN_FONTS: readonly SignFont[];

declare const SIGNATURE_MODES: readonly ["draw", "type", "upload"];

/** An uploaded picture may weigh this much. */
export declare const SIGNATURE_UPLOAD_MAX_BYTES: number;

export declare type SignatureMode = (typeof SIGNATURE_MODES)[number];

/** The modes the node offers, in the catalogue's order; every mode when it names none. */
export declare function signatureModes(raw: unknown): SignatureMode[];

/** `data.values[id]` of a signed pad. */
export declare interface SignatureValue {
    png_b64: string;
    mode: SignatureMode;
    /**
     * `type` mode only: which of the five faces the signer picked
     * (`lib/signFonts`).
     *
     * ⚠ It travels even though the PNG is already rendered in that face,
     * because the plugin may re-render the name at print resolution rather
     * than upscale a 600×200 bitmap — and it cannot ask the screen which
     * font was used after the fact.
     */
    font?: SignFontKey;
}

export declare interface SignFont {
    key: SignFontKey;
    /** What the person sees in the picker — a font's name is not translated. */
    name: string;
    /** Handwriting faces are offered first; the formal pair closes the list. */
    kind: 'hand' | 'formal';
    /** The class `styles/sign-fonts.css` declares for this key. */
    className: string;
    /**
     * The same stack as a string, for a canvas `ctx.font` (canvas takes no
     * class). ⚠ `inter` resolves through `var(--fe-font)` in CSS but a canvas
     * cannot read a custom property, so its literal stack is spelled out here
     * and kept in step with `styles/variables.css`.
     */
    stack: string;
}

/** The named face, or the default — never `undefined`, so no caller branches. */
export declare function signFont(key: unknown): SignFont;

/**
 * signFonts — the closed set of faces a signature may be written in.
 *
 * A typed signature and a `pdf-fields` text field both let the signer choose
 * how their words are drawn, and the choice TRAVELS: it rides back to the
 * plugin as `font` (see docs/APP-PLUGINS-API.md → `pdf-fields` props), which
 * then stamps the PDF in that face. So the browser and the stamping plugin
 * have to agree on a small, stable vocabulary — five keys, not a free-text
 * CSS family — and this file is that vocabulary.
 *
 * ⚠ ONE definition, three readers: the signature pad's "type" mode, the
 * pdf-fields overlay and anything that later re-renders a stored value. A
 * second copy is how a signature typed in Caveat comes back in Inter.
 *
 * ⚠ The faces themselves are self-hosted (`styles/sign-fonts.css` +
 * `assets/fonts/`), never a CDN: see that stylesheet's note for why a signing
 * screen in particular must not phone out for a font.
 */
/** The wire value of a `font` choice. */
export declare type SignFontKey = 'caveat' | 'dancing-script' | 'homemade-apple' | 'inter' | 'source-serif';

/**
 * aessiv — AES-SIV (RFC 5297) on top of WebCrypto.
 *
 * WebCrypto has no SIV mode, so it is assembled here from the two primitives
 * it does have, exactly as the RFC defines it:
 *
 *   - AES-CMAC (RFC 4493) — computed with AES-CBC under a zero IV. CBC-MAC of
 *     the prepared message IS the CMAC; WebCrypto's CBC always appends a
 *     PKCS#7 padding block, which we simply ignore.
 *   - S2V (RFC 5297 §2.4) — CMAC over the associated-data strings and the
 *     plaintext, chained with doubling in GF(2^128).
 *   - CTR (RFC 5297 §2.5) — AES-CTR with the synthetic IV as the counter,
 *     bits 31 and 63 cleared. With those bits cleared a 32-bit counter can
 *     never carry for any message shorter than 2^31 blocks, so WebCrypto's
 *     `length: 32` counter is bit-for-bit the RFC's 128-bit addition.
 *
 * Output layout: V (16 bytes, the synthetic IV / tag) || C (same length as P).
 *
 * Key: 32 bytes = AES-128-SIV, 64 bytes = AES-256-SIV. The left half keys
 * S2V (CMAC), the right half keys CTR (RFC 5297 §2.6).
 *
 * Why SIV at all: it is DETERMINISTIC authenticated encryption. The same key
 * and the same plaintext always give the same ciphertext, and any change to
 * the ciphertext fails the tag. For file names that is the property we want:
 * the server can keep enforcing "one name per folder" on the ciphertext, and
 * a name that does not decrypt is recognisably not one of ours. See
 * docs/E2E-ENCRYPTION.md → "Encrypted names".
 *
 * Measured against RFC 5297 appendix A and against an independent
 * implementation (Python `cryptography`'s AESSIV) in
 * web/tests/lib/e2enames.test.ts; the Go twin is backend/internal/e2edecrypt.
 */
/** A prepared AES-SIV key: the two halves imported for their one job each. */
declare interface SivKey {
    /** S2V half, as AES-CBC (the CMAC engine). */
    mac: CryptoKey;
    /** CTR half. */
    ctr: CryptoKey;
    /** CMAC subkeys K1/K2 of the S2V half (RFC 4493 §2.3). */
    k1: Uint8Array;
    k2: Uint8Array;
}

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';

/** `"a، b ,c"` → `["a", "b", "c"]`. */
export declare function splitList(raw: string | null | undefined, opts?: SplitListOptions): string[];

/**
 * listInput — the ONE splitter for "several things typed into one field":
 * recipients, extensions, tags, identities, a multi-select's stored answer.
 *
 * ⚠⚠ The comma is not one character. An Arabic, Persian or Urdu keyboard
 * types "،" (U+060C ARABIC COMMA) where an English one types ",", Chinese and
 * Japanese input methods type "，" (U+FF0C FULLWIDTH COMMA) or "、" (U+3001
 * IDEOGRAPHIC COMMA), and the semicolon has its own Arabic (U+061B "؛") and
 * fullwidth (U+FF1B "；") forms. Every list field used to split on the ASCII
 * characters only, so `a@x.com، b@y.com` — exactly what a person writing in
 * Arabic produces — became ONE malformed address and the share mail said
 * "enter a valid email" about a perfectly valid list. Five fields each carried
 * their own `split(/[,…]/)`; they all read through here now, so the next
 * script's comma is added once.
 *
 * Items are trimmed and empty ones dropped; nothing else is decided here
 * (lower-casing, de-duplication, "does it contain an @" stay with the caller,
 * which knows what an item is).
 */
export declare interface SplitListOptions {
    /** Whitespace separates items too (never for tags, which may contain a space). */
    spaces?: boolean;
    /** Semicolons separate items too (a mail client's recipient habit). */
    semicolons?: boolean;
    /** Line breaks separate items too (a pasted column). Implied by `spaces`. */
    newlines?: boolean;
}

/** 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_51, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
host: string;
port: number;
login: string;
enabled: boolean;
hasKey: boolean;
ftps?: FTPSFacts;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_51> & 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>;

/**
 * Whether a status's own words tell a person something the caller's words
 * would not: a refusal they can act on (401 sign in, 403 not allowed, 404
 * gone, 409 conflict, 413 too large, 429 slow down…). A 5xx, or a status with
 * no words of its own, says only "it failed" — the caller's sentence for what
 * it was doing ("Your changes could not be saved") says more.
 */
export declare function statusIsTelling(status: number): boolean;

/** A status's words. ⚠ An unlisted status is NOT printed as "Error (418)":
 *  a number is not a sentence, and it is the one thing this file exists to
 *  keep off the screen. */
export declare function statusWords(status: number, locale: string | undefined): string;

/**
 * Left and right along the top entries, in the direction the interface is
 * drawn: in a right-to-left interface the right arrow goes to the PREVIOUS
 * entry. Wraps, as a menu bar does. `null` for any other key.
 */
export declare function stepAlongBar(key: string, index: number, count: number, dir?: TextDirection): number | null;

/**
 * Where a key press inside a run of links moves focus: the next or previous
 * one, the first or the last. `null` for a key this does not handle. The
 * run does not wrap - Down on the last link stays there - which is how a
 * reader knows they reached the end.
 */
export declare function stepFocus(key: string, index: number, count: number): number | null;

/** A footer, arranged: Back on the left, the ordinary buttons, one primary last. */
export declare interface StepFooter {
    back: SurfaceAction | null;
    /** In declaration order, minus Back and minus the one primary. */
    others: SurfaceAction[];
    primary: SurfaceAction | null;
}

/**
 * Arrange a surface's actions for a step.
 *
 * `stepped` is what `hasSteps` said. On a surface that is NOT a step the
 * plugin's own arrangement is left alone — a dialog with two equally weighted
 * actions is a legitimate screen, and the rule is about walks.
 */
export declare function stepFooter(actions: SurfaceAction[] | undefined, stepped: boolean): StepFooter;

export declare interface StepsNodeProps {
    items: Array<{
        id: string;
        label: PluginText | string;
        state?: StepState | string;
    }>;
}

export declare type StepState = 'done' | 'active' | 'todo';

/** How often the list is read while anything is followed. */
export declare const STORAGE_WATCH_MS = 3000;

/**
 * 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;
    /**
     * Draw the choice as BUTTONS rather than a dropdown — every option on the
     * screen, readable without clicking (`components/ChoiceButtons`).
     *
     * ⚠ Set by the DECLARATION, not by the surface drawing it. An app
     * plugin's fields always carry it (v3 §2: "no dropdowns anywhere in a
     * surface", applied by `lib/surfaceValues.storageFieldOf`), and a storage
     * driver may ask for it on a short choice. Branching on "am I in a
     * surface?" inside the renderer would be the same control behaving two
     * ways on two screens, which is the thing this package keeps un-writing.
     *
     * On a `bool` it means the two-button Yes/No decision; a bool without it
     * stays the on/off checkbox a driver setting wants.
     */
    choice?: boolean;
    /** A `select` that takes several of its options; the value is then a list. */
    multi?: 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[];
}

/**
 * A plugin's field as the shared field renderer (`components/StorageFields`)
 * reads it. `i18n_key` is empty on purpose: the renderer asks the catalogue
 * first and falls back to `label` when the key is unknown, and `''` is
 * unknown — so a plugin's own words (already read in the viewer's language)
 * are what show. `secret` fields are drawn masked whatever their type says.
 *
 * ⚠⚠ v3: `choice` is set HERE, for every plugin `select`, and `advanced` is
 * not carried at all. Those two lines are the whole of "no dropdowns and no
 * hidden sections in a surface" — applied to the declaration on its way in,
 * so the renderer stays one renderer and no plugin can opt out of the rule
 * by drawing its own control.
 *
 * ⚠⚠ This is the ONLY mapper. Every screen that turns a plugin's `Field`
 * into something drawable goes through it: the surface form
 * (`components/plugin/nodes/SurfaceForm.vue`) AND the admin's own app
 * settings screen (web `components/plugins/AppPluginDetail.vue`). There used
 * to be a second one in the admin (`api/appPlugins.fieldToStorageField`); it
 * never set `choice`, dropped `multi` and carried an `advanced` the contract
 * had already deleted, so one manifest field meant two different things on
 * two screens. A new surface adds a CALLER here, never a mapper of its own.
 */
export declare function storageFieldOf(f: PluginField, locale: string): StorageField;

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_48, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (v: Record<string, unknown>) => any;
}, string, PublicProps, Readonly<__VLS_Props_48> & 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';

/** One entry of a listing's `storage_info`. */
export declare interface StorageInfo {
    name: string;
    read_only?: boolean;
    coverage?: CatalogCoverage | null;
}

/** What the line says. */
export declare interface StorageLine {
    /** The bytes it reports. */
    used: number;
    /** The person's ceiling; 0 when there is none. */
    total: number;
    /** No ceiling — `used` is the drives' size, not the person's uploads. */
    unlimited: boolean;
    /** `used` is a lower bound. */
    partial: boolean;
}

export declare function storageLine(p: PersonUsage | null | undefined, panel: readonly PanelDrive[], measured: readonly MeasuredDrive[] | null | undefined): StorageLine | null;

export declare interface StorageOrderHandle {
    /** The saved order, as keys (`[]` = the host's order). */
    saved: Readonly<Ref<string[]>>;
    /** The person has an order of their own — what "Use default order" lets go of. */
    custom: ComputedRef<boolean>;
}

/** The key a saved order holds for this storage: its uid, else its name. */
export declare function storageOrderKey(s: OrderableStorage): string;

/** 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 const StorageTags: DefineComponent<__VLS_Props_47, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_47> & Readonly<{}>, {
enabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLSpanElement>;

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

export declare interface StorageWatch {
    /** Follows the scan of storage `id` — call it once `POST …/sync` has
     *  answered — to its end; null when the watch was stopped. A storage
     *  already followed is joined, not followed twice. */
    scan(id: number): Promise<ScanEnd | null>;
    /** Follows a deletion the server is still doing: true once the storage has
     *  left the list, false when the list could not be read (many times over),
     *  null when the watch was stopped. */
    deletion(id: number): Promise<boolean | null>;
    /** What storage `id` is followed for, or null. Reactive. */
    watching(id: number): StorageWatchKind | null;
    /** Stops every follower (the page went away): each ends with null. */
    stop(): void;
}

declare type StorageWatchKind = 'scan' | 'deletion';

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

export declare interface StoredName {
    kind: StoredNameKind;
    /** For 'long', 'longdir' and 'sidecar': the 43-char hash they share. */
    hash?: string;
    /** For 'file'/'dir': the encoded ciphertext. */
    encoded?: string;
    /** For 'dir'/'longdir': the folder's id. */
    dirId?: Uint8Array;
}

export declare type StoredNameKind = 'file' | 'dir' | 'long' | 'longdir' | 'sidecar' | 'plain';

export declare interface StreamDecryptOptions {
    /** Fail when the plaintext is not exactly this long (the header said so). */
    expectSize?: number;
}

export declare interface StreamEncryptOptions {
    /** Refuse a plaintext that is not exactly this long (the header promised it). */
    expectSize?: number;
    /** Called with the plaintext bytes consumed so far. */
    onProgress?: (bytes: number) => void;
}

/** Bytes of a 0x02 folder file carrying `plainSize` bytes. */
export declare function streamFolderFileSize(plainSize: number, log2?: number): number;

/**
 * The values to POST: everything the surface holds, minus what a hidden
 * field was carrying.
 *
 * ⚠ Dropped, not blanked. `{name: ""}` is an answer ("call it nothing");
 * the contract says the value "is dropped before the job runs", so the key
 * must not be in the map at all.
 */
export declare function stripHiddenValues(nodes: SurfaceNode[] | undefined, values: Record<string, unknown>): Record<string, unknown>;

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

/** The contract's debounce for `form` edits → `event: "change"`. */
export declare const SURFACE_CHANGE_DEBOUNCE_MS = 300;

/** A footer button (wire.SurfaceAction). */
export declare interface SurfaceAction {
    id: string;
    label: PluginText;
    primary?: boolean;
    danger?: boolean;
    disabled?: boolean;
}

/** What the value-holding and file-reading nodes need from the explorer's API. */
declare type SurfaceApi = Pick<FileApi, 'index' | 'pluginUsers' | 'fetchBlob'>;

export declare const SurfaceConversation: DefineComponent<__VLS_Props_28, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_28> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const SurfaceFooterButtons: DefineComponent<__VLS_Props_29, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_29> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/**
 * The values a surface arrives with: `form.props.values` (flat, by field key,
 * else each field's `default`), `people-picker.props.value`,
 * `file-chooser.props.value`, a `pdf-fields` node's fields and an empty
 * `signature-pad` under the node's id. Nodes without an id hold nothing the
 * server can address, so they contribute nothing.
 */
export declare function surfaceInitialValues(nodes: SurfaceNode[] | undefined): Record<string, unknown>;

/** wire.JobRequest — the surface asks the host to enqueue an action. */
declare interface SurfaceJobRequest {
    action_id: string;
    params?: Record<string, unknown>;
    /**
     * v2 — this one job's output, replacing the action's manifest output
     * ("same file as a new version" / "a new file beside it" / a name). The
     * server re-checks the ACL against the EFFECTIVE mode, so a surface
     * cannot turn a read-only action into a write.
     */
    output?: {
        mode: 'sibling' | 'version' | 'none' | string;
        name?: string;
    };
}

/**
 * The visible-and-required fields a person has not answered. Empty means the
 * submit may go; anything else is what to point at.
 */
export declare function surfaceMissingRequired(nodes: SurfaceNode[] | undefined, values: Record<string, unknown>): PluginField[];

/** One component of a surface (wire.Node). */
export declare interface SurfaceNode {
    id?: string;
    type: string;
    props?: Record<string, unknown>;
    children?: SurfaceNode[];
}

export declare interface SurfaceOpenOptions {
    /** The plugin that answered — the screen named is one of ITS own. */
    plugin: string;
    /** The prefix the SPA is served from (`/admin/`, `/drive/`). */
    base?: string | null;
    /**
     * What placement the named view has, when the frame knows. `page` opens in
     * a tab on the view's own address; anything else (and an unknown one) goes
     * through the explorer, which is the frame that can open a dialog.
     */
    placementOf?: (id: string) => string | undefined;
}

/**
 * v3 §3.0 — `wire.OpenRequest`: "go to this file, and start this there".
 * `action` or `view`, never both; neither just opens the file.
 */
declare interface SurfaceOpenRequest {
    /** Adapter-qualified (`docs://reports/nda.pdf`). */
    path: string;
    action?: string;
    view?: string;
}

/** What the answer amounts to, once the frame knows where it is mounted. */
export declare interface SurfaceOpenTarget {
    href: string;
    /**
     * A `page` view is a whole screen with the document beside it and opens in
     * its own tab — the same rule a `page` ACTION follows when it is clicked
     * in the menu, so a plugin's screen behaves the same however it was
     * reached.
     */
    newTab: boolean;
}

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

export declare const SurfaceRenderer: DefineComponent<__VLS_Props_27, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
change: () => any;
action: (p: {
action_id: string;
row_id: string;
}) => any;
"update:values": (v: Record<string, unknown>) => any;
}, string, PublicProps, Readonly<__VLS_Props_27> & Readonly<{
onChange?: (() => any) | undefined;
onAction?: ((p: {
action_id: string;
row_id: string;
}) => any) | undefined;
"onUpdate:values"?: ((v: Record<string, unknown>) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

/** One entry of a home page's menu. */
declare interface SurfaceSection {
    id: string;
    label: PluginText;
    /** Drawn beside the label (rows waiting there); absent draws none. */
    count?: number;
}

export declare const SurfaceSignaturePad: DefineComponent<__VLS_Props_31, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (v: SignatureValue | null) => any;
}, string, PublicProps, Readonly<__VLS_Props_31> & Readonly<{
"onUpdate:modelValue"?: ((v: SignatureValue | null) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
canvas: HTMLCanvasElement;
fileInput: HTMLInputElement;
}, HTMLDivElement>;

export declare type SurfaceTone = 'muted' | 'danger' | 'info';

/**
 * Keep `root`'s `dir` derived from its `lang`, for as long as the page lives.
 *
 * ⚠ An observer on `lang`, not a call from each place that sets the language:
 * there are several (the admin panel's language decision, the public link
 * page, and whatever sets it next), and a direction that each of them had to
 * remember to set is a direction one of them forgets. The observer's callback
 * runs as a microtask — before the next paint — so the words and the layout
 * turn together.
 *
 * ⚠ Also re-applied when the language LIST changes: a pack's language can be
 * on `<html lang>` before the list saying it is right to left has arrived
 * (the admin panel holds a stored choice while the list is in flight).
 *
 * Only for a host that owns the whole page. An embed never calls this — the
 * host page's direction is the host's business (see the rule above).
 *
 * @returns a stop function (tests, hot reload).
 */
export declare function syncDocumentDir(root?: HTMLElement | null): () => void;

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

/**
 * A translator.
 *
 * ⚠⚠ `foreign` is how a failure carries its reader's DIRECTION. Half of what
 * this file puts on a screen is text filex did not write — the server's own
 * sentence, an app's own words — and none of it passes through
 * `useLocale().t` or the admin panel's post-translation hook, so in Arabic
 * none of it was isolated: a path, a URL or a token syntax inside the
 * sentence lost its neutral characters to the paragraph's direction
 * (lib/direction `foreignText`, measured on `server.token.scope_unknown`).
 * Threading a locale code through five signatures would have been five
 * chances to forget it; the translator already travels with every call, so it
 * carries the answer. A `t` that does not know (a test stub, a literal
 * fallback) simply passes the text through.
 */
declare interface T {
    (key: string, vars?: Vars): string;
    /** Machine runs inside this language's sentences, isolated (RTL only). */
    foreign?: (text: string) => string;
}

export declare const TabBar: DefineComponent<__VLS_Props_41, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (id: string) => any;
close: (id: string) => any;
"toggle-inspector": () => any;
new: () => any;
reorder: (from: number, to: number) => any;
"toggle-split": () => any;
}, string, PublicProps, Readonly<__VLS_Props_41> & Readonly<{
onSelect?: ((id: string) => any) | undefined;
onClose?: ((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;
}

export declare const TABLE_ENV: InjectionKey<TableEnv>;

/** The backing a `ColumnStore` for table `id` reads and writes through. */
export declare function tableColumnBacking(id: string): ColumnBacking;

/**
 * The stretch of the order a movable column may occupy — `[lo, hi]`, both
 * inclusive indices into `order`.
 *
 * ⚠ The pinned columns are not just un-draggable, they are also un-passable:
 * the lead is the row's handle and stays first, the explorer's star is a
 * control that lives beside the row menu and stays last. Measured 2026-09-20:
 * dropping Type at the end of the drawn columns put it PAST the star, so the
 * header read `… Size ★ Type ⋮` and the Type label stood over a 24px control
 * column. The band is derived rather than hard-coded so a pinned column at
 * either end of ANY table is honoured without another rule remembering to.
 */
export declare function tableColumnDropBand<Id extends string>(order: readonly Id[], specs: readonly TableColumnSpec<Id>[]): {
    lo: number;
    hi: number;
};

/** One column the table knows how to draw. */
export declare interface TableColumnSpec<Id extends string = string> {
    id: Id;
    /** Shipped width in px. */
    width: number;
    min: number;
    max: number;
    /** May the person hide it from the column menu? Also what makes it MOVABLE:
     *  a column the person cannot hide is pinned where the table put it (the
     *  explorer's Name first, its star last). */
    hideable: boolean;
    /** May the person drag its edge? */
    resizable: boolean;
}

export declare interface TableEnv {
    locale: Ref<LocaleCode>;
    theme?: Ref<ThemeMode | undefined>;
}

/** What one explorer table looks like right now. */
export declare interface TableLayout {
    visible: ColumnId[];
    widths: Record<ColumnId, number>;
    total: number;
    auto: boolean;
}

/** The explorer's table arithmetic over the DEFAULT layout. A folder's own
 *  layout is `folderColumnStore(key).layout(…, EXPLORER_METRICS)`. */
export declare function tableLayout(available: number, candidates: readonly ColumnId[], opts?: {
    gap?: number;
    padding?: number;
}): TableLayout;

/** The table's remembered sort, or null. */
export declare function tableSort(id: string): {
    key: string;
    dir: 'asc' | 'desc';
} | null;

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;
}

/** A tag as the server hands it out: its name as typed and its kind. */
export declare interface TagItem {
    name: string;
    kind: TagKind;
    /** The tag's identity, the server's (`internal/tagname.Key`): two names
     *  with one key are one tag. A 0.54+ server sends it with every item; it is
     *  never sent back. */
    key?: string;
}

/**
 * The items in a tag answer. A v0.43+ server sends `items: [{name, kind}]`; an
 * older one sends only `tags: string[]` — and on an older server every tag was
 * shared with everybody, so those are TEAM tags. Anything malformed is dropped.
 */
export declare function tagItemsOf(body: unknown): TagItem[];

/**
 * tags.ts — the list of tags that exist, for the navigation panel.
 *
 * `GET /api/files/manager/tags/all` is one query per call, and the panel is
 * rendered by every mounted explorer: the web app, the desktop app and every
 * embed on a page (work.example.com renders two side by side). Asking on each mount
 * would multiply a database scan by however many explorers a host happens to
 * put on screen, for a list that changes when somebody edits a tag — i.e.
 * rarely.
 *
 * So: a MODULE-level cache, shared by every instance in the page.
 *   - in-flight requests are deduped, so N explorers mounting in the same tick
 *     produce ONE request;
 *   - the answer is reused for TTL_MS;
 *   - `invalidateTagCache()` drops it the moment tags are written, so the
 *     panel is never stale after the user's own edit — which is the only
 *     staleness a user can actually notice.
 *
 * Keyed by apiBase: the desktop app can point at a different server between
 * mounts and must not be handed the previous server's tags.
 */
/**
 * The two kinds of tag (v0.43.0, the owner's decision "tagler personal ve team
 * olarak ikiye ayrılır"):
 *
 *   personal — the person's own label, like a star. Nobody else sees it.
 *   team     — shared with everyone in the tenant who can see the file;
 *              adding or removing one needs edit permission on the file.
 *
 * ⚠ Before v0.43.0 there was one kind and it was shared with EVERY account on
 * the server while the code called it per-user — a tester's "müşteri teklifi"
 * showed in other people's panels and they could remove it. A tag on screen
 * therefore always says which kind it is (`TagKindIcon` + the words), so
 * nobody has to guess who can see it.
 */
export declare type TagKind = 'personal' | 'team';

export declare const TagKindIcon: DefineComponent<__VLS_Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_5> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, SVGSVGElement>;

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

/**
 * Take what a capabilities answer says. A field the answer leaves out keeps
 * what is held (an answer from an older server, or a partial host stub, does
 * not wipe a real one).
 */
export declare function takeServerRules(caps: {
    edit_kinds?: Partial<EditKinds> | null;
    limits?: ServerLimits | null;
} | null | undefined): void;

export declare type TextDirection = 'ltr' | 'rtl';

export declare interface TextNodeProps {
    text?: PluginText | string;
    /** Accepted alias of `text` (M1). */
    value?: PluginText | string;
    tone?: SurfaceTone | string;
    heading?: boolean;
}

/**
 * ⚠⚠ `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 — what a palette choice stores (on the account where the host
     *  keeps preferences there, `lib/prefs`; mirrored in localStorage for the
     *  first paint), never shown to users. */
    id: string;
    /**
     * i18n catalogue key for the display name (tr + en).
     *
     * ⚠ Built-in palettes only. An operator's own theme carries `name` instead:
     * "Acme Bulut" is not a string this product translates, and putting it
     * through `t()` would print the key straight back at them the first time
     * somebody named a theme something the catalogue did not contain.
     */
    nameKey?: string;
    /** Literal display name — operator-defined themes only (tema:v1). */
    name?: 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_35, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (id: string) => any;
close: () => any;
mode: (mode: ThemeModePref) => any;
}, string, PublicProps, Readonly<__VLS_Props_35> & Readonly<{
onSelect?: ((id: string) => any) | undefined;
onClose?: (() => 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';

/** The display name of a theme, translated for built-ins and literal for an
 *  operator's own. */
export declare function themeName(theme: ThemeDef, t: (key: string) => string): string;

export declare const ThemePalette: DefineComponent<__VLS_Props_36, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
select: (id: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_36> & 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>;

/** Why a file has no thumbnail, when the reason is the file's own (`thumb_note`). */
export declare type ThumbNote = 'corrupt' | 'encrypted' | 'too_large';

/**
 * ⚠⚠ 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_37, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (v: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_37> & 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;

/** Today as `YYYY-MM-DD` in the local calendar — the `date` field's auto value. */
export declare function todayIso(now?: Date): string;

export declare const TokensPanel: DefineComponent<__VLS_Props_53, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
active: (v: {
hasToken: boolean;
}) => any;
}, string, PublicProps, Readonly<__VLS_Props_53> & 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. ⚠ The guard is the point: bumping an absent key would
 * create an entry for every folder anyone opens.
 */
export declare function touchFolder(key: string): void;

/** This browser's copy. The name is the one every earlier release wrote. */
export declare const TOUR_LS_KEY = "filex.tourDone";

/** Has this person — here, or on the account — already been offered the tour? */
export declare function tourSeen(): boolean;

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

export declare type Translate = (key: string, vars?: Record<string, string | number>) => string;

/**
 * `t()` for code that is not a component (`lib/shareTtl`): the same lookup,
 * the same plural rule, the same placeholders. ⚠ Not reactive — a caller that
 * renders the result in a template must read `localesVersion` itself.
 */
export declare function translate(code: LocaleCode | string | undefined, key: string, vars?: Record<string, string | number>): string;

/** The explorer's address for the Trash view (lib/listing.ts VIRTUAL_SEGMENTS). */
export declare const TRASH_VIEW_PATH = ".trash";

/**
 * A batch restore or permanent delete of trash entries, as the server answers
 * it: how many went (or, `queued`, are on their way as `ops`), how many did
 * not, why the first of those did not, and `summary`, the server's sentence
 * for all of it in the screen's language — what the explorer shows.
 */
declare interface TrashBatchAnswer {
    done: number;
    failed: number;
    reason_code?: 'exists' | 'not_found' | 'forbidden' | 'failed';
    /** The entries a restore found their place taken for. */
    taken?: string[];
    queued?: boolean;
    ops?: PendingOpDto[];
    summary: string;
}

/** "Empty trash" asked as a dry run: what it would delete, and the
 *  confirmation's sentence. */
declare interface TrashEmptyPreview {
    dry_run: true;
    count: number;
    bytes: number;
    summary: 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;
    /** Who put it in the Trash; every key absent when nobody is named. */
    deleted_by_id?: number;
    deleted_by_name?: string;
    /** The asker's own delete ("You"). */
    deleted_by_self?: boolean;
    /** One of the asker's own drafts (#71), discarded: it came from Drafts,
     *  and Restore puts it back there. `path` is then just its name. */
    draft?: boolean;
}

/** One page of the trash listing, and the server's totals for ALL of it.
 *  ⚠ `total`, `total_bytes` and `storages` count every entry the caller may
 *  see, not the page: the size and the count a screen shows come from here,
 *  never from summing the rows it has loaded (0.54, finding D1). */
declare interface TrashPage {
    entries: TrashEntry[];
    total: number;
    total_bytes?: number;
    newest_deleted_at?: string | null;
    storages?: TrashStorageSummary[];
    /** How much the trash holds, said by the server in the screen's language. */
    summary?: string;
    limit?: number;
    offset?: number;
}

/** One storage's part of the caller's trash, as the server counts it: what
 *  that storage's virtual `.trash` row shows. */
declare interface TrashStorageSummary {
    storage_id: number;
    storage_name?: string;
    count: number;
    bytes: number;
    newest_deleted_at: string | null;
}

/**
 * The Trash's "time left" for one item, in words: the server's own count of
 * whole days before it is purged (`ttl_days`, trash/service.go — retention
 * minus the days since deletion, never below zero).
 *
 *   30 → "30 days"   1 → "1 day"   0 → "Due for deletion"   none → "—"
 *
 * ⚠ ONE sentence for one concept, shared by the explorer's Trash view
 * (ListView) and the admin panel's Trash page. They used to carry two key
 * families for it — `trash.days_left` in the explorer's table and
 * `trash.days_remaining` in the admin panel's — and the admin page printed
 * "0 days" for an item the explorer called due for deletion. The keys live in
 * the explorer's table (`trash.days_remaining`, `_one`, `_due`); a caller
 * hands its own `t` so a surface keeps its own reactivity.
 */
export declare function trashTimeLeft(ttl: number | null | undefined, t: (key: string, vars?: Record<string, string | number>) => string): string;

/**
 * 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[];

/**
 * prefs — the look-and-language preferences, kept on the ACCOUNT.
 *
 * ⚠⚠ Why this module exists: a palette picked in one browser was not there
 * in the next one. Theme, palette, density and language were each stored in
 * `localStorage` and nowhere else, so every device — and every private
 * window, and every cleared cache — started the product over with somebody
 * else's defaults. They are a PERSON's preferences, not a machine's.
 *
 * So the answer lives on the account: `GET /api/me/prefs?surface=web` on
 * boot, `PUT /api/me/prefs?surface=web` on every change, debounced.
 *
 * ⚠ `localStorage` stays, and stays for exactly ONE job: the first paint.
 * The fetch cannot beat the first frame, so the mirror is what stops the
 * window flashing the stock palette on the way to the chosen one. It is a
 * CACHE of the account's answer, never the answer — when the server's
 * values land they overwrite it.
 *
 * ⚠⚠ ONE module, several surfaces. The web app asks for `surface=web` and
 * the desktop app for `surface=desktop` — same code, same keys, same
 * debounce; only the query differs, because a person may legitimately want
 * a dense list on a laptop and a roomy one on a wall screen. There is no
 * per-surface BRANCH anywhere in here, and there must not be one: a
 * behaviour that exists on one surface only is the bug this product keeps
 * having to un-write.
 */
/** The preferences an account carries for one surface. */
export declare interface UiPrefs {
    /** `light` | `dark` | `auto`. */
    theme?: string;
    /** A palette id from `lib/themes` (`default`, `night-blue`, …). */
    palette?: string;
    /** `comfortable` | `compact`. */
    density?: string;
    /** A language tag the interface offers (`lib/uiLocales`). */
    locale?: string;
    /**
     * The order this person put their storages in, in the navigation panel
     * (GitHub #57) — a JSON list of storage keys (`lib/storageOrder`). Absent or
     * empty = the host's own order, which is what everybody who never reordered
     * keeps seeing.
     *
     * ⚠ A string, like every other value here: `sanitize` keeps strings only, so
     * a raw array would be dropped on the way in and erased on the next write.
     */
    storageOrder?: string;
    /**
     * Set (to `done`) once the first-use tour has been OFFERED to this person
     * (`lib/tour`). Not a look: it has no first-paint mirror of its own, and it
     * only ever goes one way — nothing in the product clears it.
     */
    tour?: string;
    /**
     * v4 — what apps' own interfaces keep for this person (`state.set` over the
     * bridge; lib/appState): a JSON object `{app: {key: value}}`. An interface
     * runs on an opaque origin with no storage of its own, so this is its only
     * way to remember anything, and it follows the person like the rest.
     */
    appState?: string;
    /**
     * v4 — the app versions this person has been told about (lib/appState): a
     * JSON object `{app: version}`. An administrator approved a new version →
     * the next time the person opens that app, the "updated" note shows once.
     */
    appsSeen?: string;
    /**
     * 0.50 - "always open this kind with this app" (lib/openWith): a JSON object
     * `{ext: handlerId}`, the handler `builtin` or `app:<plugin>/<view>`. A
     * choice the administrator has since switched off is kept, and not used,
     * until the person picks another (Settings → Preferences → Default apps
     * says so).
     *
     * ⚠⚠ ONE record per ACCOUNT, not per surface (ACCOUNT_KEYS): the server
     * hands it in with every surface's document and drops it from every PUT;
     * it changes one kind at a time through `/api/me/open-with`
     * (`accountFetch`), so a copy this page read at boot cannot undo a choice
     * made since on another surface.
     */
    openWith?: string;
}

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

/** The words for an unavailable entry. */
export declare interface UnavailableWords {
    /** The badge's visible text: one character, the row is narrow. */
    badge: string;
    /** What it means and what will happen, in a sentence. */
    why: string;
    /** The storage's own answer, '' when it sent none. */
    reason: string;
    /** `why` and `reason` together: a tooltip, an aria-label, a toast. */
    full: string;
}

/**
 * The words for an unavailable entry, or `null` for every ordinary row.
 *
 * ⚠ Literal `t('…')` keys on purpose: `web/tests/i18n/coreKeysUsed.test.ts`
 * scans the source for them and skips anything computed.
 */
export declare function unavailableWordsFor(node: Pick<FileNode, 'unavailable' | 'unavailable_reason' | 'type'> | null | undefined, host: UnavailableWordsHost): UnavailableWords | null;

/** What `unavailableWords` needs from the caller's locale. */
export declare interface UnavailableWordsHost {
    t: (key: string, vars?: Record<string, string | number>) => string;
}

/**
 * A path relative to the SERVER ROOT, joined onto an API base, keeping the
 * base's own path.
 *
 * The server hands out some addresses relative to its root — a thumbnail's
 * `thumb_url`, a selection archive's `/z/<ticket>` — because it cannot know
 * where its reader sees it: the admin app at `/filex`, the desktop app at
 * `https://example.com/filex`, an embed through its host's proxy at
 * `https://host.example/files-proxy`. The reader knows, and its API base
 * (`apiBase`, the server root WITHOUT `/api`) is that answer.
 *
 * ⚠ Not `new URL(path, apiBase)`: a root-relative path resolved that way drops
 * the base's path, which is precisely the prefix a sub-path deployment or a
 * proxying host lives under.
 *
 * An absolute `path` is returned unchanged; an empty base leaves the path
 * relative to the page's own origin (same-origin at the root, as before).
 */
export declare function underApiBase(apiBase: string | null | undefined, path: string): string;

/**
 * Open a `.fxe` header with a password, its recovery key or the escrow key.
 * 'wrong': the credential does not open it. 'damaged': it did (or the header
 * gives no way to tell), and the file key or the name is unreadable.
 */
export declare function unlockFxe(h: FxeHeader, cred: FxeCredential): Promise<FxeUnlock>;

/**
 * Unwrap the folder's name key with the FMK an unlock returned. Null when the
 * folder has no encrypted names, or the slot does not open under this FMK
 * (a marker from another folder, or a damaged one).
 */
export declare function unlockNameKey(marker: E2eMarker, fmk: CryptoKey): Promise<E2eNameKey | null>;

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

/** The boxes still waiting for a place, in the order they were defined. */
export declare function unplacedFields(list: PdfField[]): PdfField[];

/** Above this the badge stops counting and starts saying "more than this". */
export declare const UNREAD_BADGE_MAX = 99;

export declare const UnreadBadge: DefineComponent<__VLS_Props_10, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_10> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

/**
 * The number an OS-level badge (dock, taskbar, tray) should carry.
 *
 * ⚠ NOT clamped to 99. macOS and Unity draw the number themselves and are
 * perfectly happy with 137; clamping it there would be this module inventing a
 * limit the platform does not have. The 99 ceiling is about how much room a
 * 16px circle has, which is a fact about the DOM badge and nothing else.
 */
export declare function unreadBadgeCount(count: number | null | undefined): number;

/**
 * What the badge SAYS. `''` when there is nothing to show — a zero badge is
 * not a small badge, it is no badge, and the caller renders nothing.
 *
 * ⚠ Non-finite and negative counts read as nothing rather than as `NaN`: the
 * count arrives from a network response, and a badge is not the place to
 * discover that a server answered oddly.
 */
export declare function unreadBadgeLabel(count: number | null | undefined): string;

/** An app was removed: its languages go with it. */
export declare function unregisterPluginLocales(plugin: string): void;

/**
 * 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;
    /** What to call the file on screen when it is not `file.name` — an upload
     *  into an encrypted-names folder carries its ciphertext name in `file`. */
    displayName?: string;
    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;
    /** The file — or, with `source`, only its identity (name, type). */
    file: File;
    /**
     * wiring:e2 stream — where the bytes come from when they are MADE as they
     * are sent (a file encrypted in the browser): `source.size` is the upload's
     * size and `file` only names it. Such an upload is not bookmarked for a
     * resume after a reload — its bytes are gone with the tab.
     */
    source?: UploadSource;
    /**
     * wiring:e2 convert - query parameters for the COMMIT, the moment the file
     * is replaced: `expect` (the overwrite precondition "<size>:<ms>") and
     * `e2e_convert` (an in-place E2E conversion write, which keeps no version
     * of the plaintext it replaces). The server checks both there
     * (upload_staged.go → Commit).
     */
    commitQuery?: Record<string, string>;
    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;
}

/**
 * uploadSource — bytes for a staged upload that are MADE as they are sent.
 *
 * A file encrypted in the browser (a single encrypted file, a large file in an
 * encrypted folder, a password change that re-sends a body) is a stream: its
 * size is known up front, its bytes are not, and building it as one Blob first
 * would hold the whole thing in memory. `useUploadChunked` takes a source
 * instead of a File for those, and asks it for one chunk at a time.
 *
 * A source is read FORWARD. The staged protocol may ask for the chunk it last
 * got again (a retry after a lost answer) or restart inside it (the server's
 * offset moved), so the last range handed out is kept; asking for anything
 * before it is an error — a stream cannot rewind. That is also why a sourced
 * upload is not bookmarked for a resume after a reload: the bytes it would
 * resume are gone with the tab (and, for an encrypted file, with its key).
 */
declare interface UploadSource {
    /** Bytes the upload carries. */
    size: number;
    /** Bytes [start, end). Starts never go below the last range returned. */
    read(start: number, end: number): Promise<Blob>;
    /** Stop producing (the upload failed or was cancelled). */
    cancel?(): void;
}

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>;
    realm: Ref<string | null, string | 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[];
};

/** Reactive handle for components that render the palette list. */
export declare function useCustomThemes(): {
    customThemes: Ref<ThemeDef[]>;
};

export declare function useFileApi(config: ExplorerConfig): {
    wsTicket: () => Promise<{
        ticket: string;
        ws_url: string;
    } | null>;
    index: (path: string) => Promise<ManagerResponse>;
    search: (path: string, filter: string, narrow?: Record<string, string>) => Promise<ManagerResponse>;
    globalSearch: (query: string, opts?: {
        limit?: number;
        scope?: GlobalSearchScope;
        narrow?: Record<string, string>;
    }) => Promise<GlobalSearchHit[]>;
    globalSearchPage: (query: string, opts?: {
        limit?: number;
        scope?: GlobalSearchScope;
        narrow?: Record<string, string>;
    }) => Promise<{
        hits: GlobalSearchHit[];
        truncated?: boolean;
        total?: number;
    }>;
    matchNames: (q: string, names: string[], signal?: AbortSignal) => Promise<number[]>;
    quotaMe: () => Promise<QuotaSnapshot | null>;
    storageUsage: () => Promise<MeasuredDrive[] | null>;
    appStoreStatus: () => Promise<{
        visible: boolean;
        stores: string[];
    } | null>;
    subfolders: (path: string) => Promise<{
        folders: FileNode[];
    }>;
    newFolder: (path: string, name: string) => Promise<ManagerResponse>;
    newFile: (path: string, name: string, type: string, opts?: {
        exactName?: boolean;
    }) => Promise<NewFileResponse>;
    newFileCheck: (path: string, name: string, type: string) => Promise<NewFileCheck>;
    drafts: {
        create(path: string, name: string, type: string, opts?: {
            exactName?: boolean;
        }): Promise<{
            path: string;
            name: string;
            ext: string;
            size: number;
            mime: string;
            draft: DraftDto;
        }>;
        list(): Promise<DraftList>;
        count(): Promise<{
            count: number;
            limit: number;
        }>;
        get(key: string): Promise<DraftDto>;
        save(key: string, as?: string): Promise<DraftSaveOutcome>;
        discard(key: string): Promise<void>;
    };
    draftsBase: string;
    rename: (path: string, item: string, name: string) => Promise<ManagerResponse>;
    renameQueued: (path: string, item: string, name: string) => Promise<{
        op?: PendingOpDto;
    }>;
    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>;
    allowedAt: (items: string[], permissions: string[]) => Promise<string[][]>;
    myPermissions: () => Promise<{
        admin: boolean;
        permissions: string[];
        byFolder: string[];
    } | null>;
    restore: (source: string[]) => Promise<{
        ok: boolean;
        restored: number;
    }>;
    listTrash: (storageName?: string, page?: {
        limit?: number;
        offset?: number;
    }) => Promise<TrashPage>;
    restoreBatch: (ids: number[]) => Promise<TrashBatchAnswer>;
    restoreQueued: (ids: number[]) => Promise<{
        ops: PendingOpDto[];
        summary: string;
    }>;
    purgeTrash: (id: number, opts?: {
        queued?: boolean;
    }) => Promise<{
        op?: PendingOpDto;
    }>;
    purgeBatch: (ids: number[], opts?: {
        queued?: boolean;
    }) => Promise<TrashBatchAnswer>;
    trashEmptyPreview: () => Promise<TrashEmptyPreview>;
    purgeVersion: (id: number) => Promise<void>;
    uploadMultipart: (path: string, files: File[], onProgress?: (p: number) => void, fields?: Record<string, string>) => 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;
    }>;
    e2eCleanup: (payload: {
        path: string;
        versions: boolean;
        trash: boolean;
    }) => Promise<{
        versions_deleted: number;
        trash_purged: number;
        thumbnails_dropped: number;
        index_cleared: number;
    }>;
    e2eAllowedAt: (asks: Array<string | {
        path: string;
        kind?: E2eRequestKind;
    }>, opts?: {
        onFailed?: () => void;
    }) => Promise<E2eAnswer[]>;
    e2eRequest: (body: {
        path: string;
        kind: E2eRequestKind;
        reason: string;
    }) => Promise<{
        request: E2eRequestDto;
        created: boolean;
    }>;
    fetchHead: (path: string, n?: number) => Promise<Uint8Array>;
    transferNamed: (kind: "copy" | "move", source: string, target: string, name: string, sourceDir?: string) => Promise<{
        op: PendingOpDto;
    }>;
    pluginActions: () => Promise<PluginActionsResponse>;
    pluginActionRun: (plugin: string, action: string, body: {
        paths: string[];
        params?: Record<string, unknown>;
    }) => Promise<PluginRunResult>;
    pluginView: (plugin: string, view: string, path?: string, section?: string) => Promise<{
        surface: PluginSurface;
    }>;
    pluginViewEvent: (plugin: string, view: string, body: PluginViewEventBody) => Promise<PluginRunResult>;
    pluginUsers: (plugin: string, q: string) => Promise<PluginUsersResponse>;
    opsCancel: (id: number) => Promise<void>;
    appUIUrl: (url: string) => string;
    pluginUICall: (plugin: string, view: string, body: {
        method: string;
        params?: unknown;
        paths: string[];
    }) => Promise<{
        result: unknown;
    }>;
    pluginUISave: (plugin: string, view: string, target: {
        path: string;
    } | {
        dir: string;
        name: string;
    }, body: Blob | ReadableStream<Uint8Array>) => Promise<{
        saved: boolean;
        path: string;
        name: string;
        size: number;
    }>;
    pluginUIRead: (plugin: string, view: string, path: string) => Promise<Response>;
    pluginLicense: (plugin: string) => Promise<LicenseInfo>;
    fetchResponse: (path: string) => Promise<Response>;
    createShare: (payload: {
        path: string;
        password?: boolean;
        /** The link's life in SECONDS, counted on the server's clock (preferred:
         *  a moment worked out on this device's clock drifts with it). */
        expires_in?: number | null;
        /** RFC 3339; wins over `expires_in` when both are sent. */
        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;
            token?: string;
        };
    }>;
    listShares: (path: string) => Promise<{
        shares: ShareInfo[];
    }>;
    revokeShare: (uuid: string) => Promise<{
        success: boolean;
    }>;
    archiveList: (path: string, password?: string) => Promise<{
        entries: ArchiveEntry[];
    }>;
    archiveExtract: (path: string, options?: {
        members?: string[];
        password?: string;
        dest?: string;
    }) => Promise<{
        op?: PendingOpDto;
        keys?: string[];
        count?: number;
    }>;
    archiveCreate: (payload: {
        dest: string;
        sources: string[];
        format: ArchiveCreateFormat;
        password?: string;
        encrypt_filenames?: boolean;
        compression?: number;
        solid?: boolean;
        dictionary_size_mb?: number;
    }) => Promise<{
        op: PendingOpDto;
    }>;
    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>;
    searchGroups: (q: string) => Promise<{
        groups: GroupSuggestion[];
    }>;
    addPermission: (body: {
        path: string;
        user_id?: number;
        group_id?: number;
        level: string;
    }) => Promise<unknown>;
    updatePermission: (id: number, level: string) => Promise<unknown>;
    deletePermission: (id: number) => Promise<unknown>;
    updateGroupPermission: (id: number, level: string) => Promise<unknown>;
    deleteGroupPermission: (id: number) => Promise<unknown>;
    invitePermission: (body: {
        path: string;
        email: string;
        level: string;
        create_user?: boolean;
        role?: string;
        locale?: string;
    }) => Promise<InviteResponse>;
    shareMail: (body: {
        share: string;
        emails: string[];
        locale?: string;
    }) => Promise<ShareMailResult>;
    shareMessage: (share: string, locale?: string) => Promise<{
        subject: string;
        body: string;
        pin_withheld?: boolean;
    }>;
    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>;
    withScreenLang: (url: string) => string;
};

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

export declare function useLocale(
/**
 * ⚠ Widened past `LocaleCode` on purpose (v3 §5). The list of languages
 * the interface offers is no longer the two this package ships: an app
 * plugin may add one (`lib/uiLocales`), so the active code can be a tag
 * this file has never heard of. It resolves through `localeOwnTable`, and
 * every key the language does not have reads English.
 */
localeRef: Ref<LocaleCode | string> | (() => LocaleCode | string)): {
    t: {
        (key: string, vars?: Record<string, string | number>): string;
        foreign(text: string): string;
    };
    formatSize: (bytes: number | undefined | null) => string;
    formatNodeSize: (n: {
        size?: number | null;
        size_partial?: boolean;
    } | null | undefined) => string;
    nodeSizeHint: (n: {
        size?: number | null;
        size_partial?: boolean;
    } | null | undefined) => string | undefined;
    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;
        fxe_name?: string;
    }) => string;
    /**
     * ⚠ RTL — which way this surface's language is written (`lib/direction`,
     * the server's one list). Bind it as `dir` on anything Teleported out of
     * the explorer's root: under `<body>` a menu inherits the HOST page's
     * direction, not the language its own words are in.
     */
    dir: ComputedRef<TextDirection>;
};

/**
 * 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 useNotificationText(): {
    notificationText: (row: NotificationLike) => NotificationText;
};

export declare function useOperations(): {
    active: Ref<    {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    errorDetail: string | null;
    queued: boolean;
    cancelling: boolean;
    doneCount: number | null;
    totalCount: number | null;
    itemsDone: number | null;
    itemsTotal: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    message: string | null;
    outputs: string[];
    outputMode: string | null;
    startedAt: number;
    settledAt: number | null;
    }[], Operation[] | {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    errorDetail: string | null;
    queued: boolean;
    cancelling: boolean;
    doneCount: number | null;
    totalCount: number | null;
    itemsDone: number | null;
    itemsTotal: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    message: string | null;
    outputs: string[];
    outputMode: string | null;
    startedAt: number;
    settledAt: number | null;
    }[]>;
    history: Ref<    {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    errorDetail: string | null;
    queued: boolean;
    cancelling: boolean;
    doneCount: number | null;
    totalCount: number | null;
    itemsDone: number | null;
    itemsTotal: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    message: string | null;
    outputs: string[];
    outputMode: string | null;
    startedAt: number;
    settledAt: number | null;
    }[], Operation[] | {
    key: string;
    kind: OperationKind;
    name: string;
    percent: number | null;
    status: OperationStatus;
    error: string | null;
    errorDetail: string | null;
    queued: boolean;
    cancelling: boolean;
    doneCount: number | null;
    totalCount: number | null;
    itemsDone: number | null;
    itemsTotal: number | null;
    uploadedBytes: number | null;
    totalBytes: number | null;
    cancellable: boolean;
    retryable: boolean;
    message: string | null;
    outputs: string[];
    outputMode: string | null;
    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;
    open: (key: string, path?: string) => void;
    clearHistory: () => void;
    revealRequests: Ref<number, number>;
    reveal: () => void;
};

export declare function usePendingOps(config: ExplorerConfig, api: FileApi, opts?: UsePendingOpsOptions): {
    ops: Ref<    {
    id: number;
    op_type: PendingOpType;
    status: "pending" | "running" | "cancelling" | "done" | "error" | "cancelled";
    progress_total: number;
    progress_done: number;
    bytes_total?: number | undefined;
    bytes_done?: number | undefined;
    objects_total?: number | undefined;
    objects_done?: number | undefined;
    target_path: string | null;
    source_dir: string | null;
    source_count: number;
    error_message: string | null;
    error_code?: string | undefined;
    error_engine?: string | undefined;
    error_text?: string | undefined;
    cancellable: boolean;
    started_at: string | null;
    finished_at: string | null;
    created_at: string | null;
    plugin?: string | undefined;
    action?: string | undefined;
    label?: string | undefined;
    message?: string | undefined;
    summary?: string | undefined;
    outputs?: {
    path: string;
    }[] | undefined;
    open?: {
    path: string;
    action?: string | undefined;
    view?: string | undefined;
    } | undefined;
    }[], PendingOp[] | {
    id: number;
    op_type: PendingOpType;
    status: "pending" | "running" | "cancelling" | "done" | "error" | "cancelled";
    progress_total: number;
    progress_done: number;
    bytes_total?: number | undefined;
    bytes_done?: number | undefined;
    objects_total?: number | undefined;
    objects_done?: number | undefined;
    target_path: string | null;
    source_dir: string | null;
    source_count: number;
    error_message: string | null;
    error_code?: string | undefined;
    error_engine?: string | undefined;
    error_text?: string | undefined;
    cancellable: boolean;
    started_at: string | null;
    finished_at: string | null;
    created_at: string | null;
    plugin?: string | undefined;
    action?: string | undefined;
    label?: string | undefined;
    message?: string | undefined;
    summary?: string | undefined;
    outputs?: {
    path: string;
    }[] | undefined;
    open?: {
    path: string;
    action?: string | undefined;
    view?: string | undefined;
    } | undefined;
    }[]>;
    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 a job THIS instance registered (`register`) flips into a
     * terminal state (done|error|cancelled).
     *
     * ⚠ Only those. The list also carries other people's running jobs (an
     * administrator sees every account's, #58), and they end too: an admin's
     * explorer said "Renamed" and "3 items restored", and read its listing
     * again, for every colleague's rename and restore (#61).
     */
    onSettled?: (op: PendingOp) => void;
}

export declare function usePluginActions(api: FileApi, enabled: () => boolean): {
    enabled: ComputedRef<boolean>;
    actions: ComputedRef<PluginActionRow[]>;
    views: ComputedRef<PluginViewRow[]>;
    openRules: ComputedRef<Record<string, OpenRule>>;
    loaded: Ref<boolean, boolean>;
    error: Ref<string | null, string | null>;
    refresh: (force?: boolean) => Promise<PluginActionsResponse>;
    actionsFor: (selection: FileNode[]) => PluginActionRow[];
    byKey: (key: string) => PluginActionRow | undefined;
    run: (action: PluginActionRow, targets: FileNode[], params?: Record<string, unknown>) => Promise<PluginRunResult>;
};

export declare function usePluginSurface(host: PluginSurfaceHost, events: PluginSurfaceEvents): {
    current: Ref<    {
    title?: PluginText | undefined;
    size?: string | undefined;
    state?: Record<string, unknown> | undefined;
    nodes: {
    id?: string | undefined;
    type: string;
    props?: Record<string, unknown> | undefined;
    children?: /*elided*/ any[] | undefined;
    }[];
    actions?: {
    id: string;
    label: PluginText;
    primary?: boolean | undefined;
    danger?: boolean | undefined;
    disabled?: boolean | undefined;
    }[] | undefined;
    toast?: PluginText | undefined;
    done?: boolean | undefined;
    job?: {
    action_id: string;
    params?: Record<string, unknown> | undefined;
    output?: {
    mode: "sibling" | "version" | "none" | string;
    name?: string | undefined;
    } | undefined;
    } | null | undefined;
    errors?: Record<string, PluginText> | undefined;
    open?: {
    path: string;
    action?: string | undefined;
    view?: string | undefined;
    } | null | undefined;
    sections?: {
    id: string;
    label: PluginText;
    count?: number | undefined;
    }[] | undefined;
    section?: string | undefined;
    } | null, PluginSurface | {
    title?: PluginText | undefined;
    size?: string | undefined;
    state?: Record<string, unknown> | undefined;
    nodes: {
    id?: string | undefined;
    type: string;
    props?: Record<string, unknown> | undefined;
    children?: /*elided*/ any[] | undefined;
    }[];
    actions?: {
    id: string;
    label: PluginText;
    primary?: boolean | undefined;
    danger?: boolean | undefined;
    disabled?: boolean | undefined;
    }[] | undefined;
    toast?: PluginText | undefined;
    done?: boolean | undefined;
    job?: {
    action_id: string;
    params?: Record<string, unknown> | undefined;
    output?: {
    mode: "sibling" | "version" | "none" | string;
    name?: string | undefined;
    } | undefined;
    } | null | undefined;
    errors?: Record<string, PluginText> | undefined;
    open?: {
    path: string;
    action?: string | undefined;
    view?: string | undefined;
    } | null | undefined;
    sections?: {
    id: string;
    label: PluginText;
    count?: number | undefined;
    }[] | undefined;
    section?: string | undefined;
    } | null>;
    values: Ref<Record<string, unknown>, Record<string, unknown>>;
    busy: Ref<boolean, boolean>;
    failure: Ref<string, string>;
    footer: ComputedRef<SurfaceAction[]>;
    errors: ComputedRef<Record<string, PluginText> | undefined>;
    invalidKeys: Ref<string[], string[]>;
    setSurface: (s: PluginSurface | null, keepValues?: boolean) => void;
    updateValues: (v: Record<string, unknown>) => void;
    scheduleChange: () => void;
    post: (event: PluginViewEventBody["event"], actionId?: string, extra?: Omit<PluginViewEventData, "values">) => Promise<void>;
    press: (a: SurfaceAction) => Promise<void>;
    rowAction: (p: {
        action_id: string;
        row_id: string;
    }) => Promise<void>;
    dispose: () => void;
};

export declare function usePublicBranding(opts?: PublicBrandingOptions): {
    branding: Ref<    {
    name?: string | undefined;
    logo_url?: string | undefined;
    accent?: string | undefined;
    footer_text?: string | undefined;
    hide_powered_by?: boolean | undefined;
    theme?: "system" | "light" | "dark" | string | undefined;
    locale?: string | undefined;
    locales?: string[] | undefined;
    ui_locales?: {
    code: string;
    label?: string | undefined;
    source?: "builtin" | "plugin" | string | undefined;
    plugin?: string | undefined;
    strings?: Record<string, string> | undefined;
    rtl?: boolean | undefined;
    }[] | undefined;
    } | null, PublicBranding | {
    name?: string | undefined;
    logo_url?: string | undefined;
    accent?: string | undefined;
    footer_text?: string | undefined;
    hide_powered_by?: boolean | undefined;
    theme?: "system" | "light" | "dark" | string | undefined;
    locale?: string | undefined;
    locales?: string[] | undefined;
    ui_locales?: {
    code: string;
    label?: string | undefined;
    source?: "builtin" | "plugin" | string | undefined;
    plugin?: string | undefined;
    strings?: Record<string, string> | undefined;
    rtl?: boolean | undefined;
    }[] | undefined;
    } | null>;
    loaded: Ref<boolean, boolean>;
    name: ComputedRef<string>;
    whitelabel: ComputedRef<boolean>;
    logo: ComputedRef<string>;
    footerText: ComputedRef<string>;
    hidePoweredBy: ComputedRef<boolean>;
    themeDefault: ComputedRef<"light" | "dark" | "auto">;
    locales: ComputedRef<string[]>;
    accentStyle: ComputedRef<Record<string, string>>;
    load: () => Promise<PublicBranding | null>;
};

export declare function usePublicLink<TInfo extends {
    needs_pin?: boolean;
    unlocked?: boolean;
    expired?: boolean;
    revoked?: boolean;
    locked?: boolean;
}>(url: PublicRoot, opts: PublicLinkOptions & {
    /** True when this link's body is an app plugin's surface. */
    hasSurface?: (info: TInfo) => boolean;
}): PublicLinkStore<TInfo>;

/** @deprecated Use `usePublicShare` — an app's public page IS a share (v3 §1.1). */
export declare function usePublicPage(token: string, opts: PublicPageClientOptions & {
    errorText: () => string;
}): PublicLinkStore<PublicPageInfo>;

export declare function usePublicRequest(token: string, opts: PublicLinkOptions): {
    uploads: Ref<{
        name: string;
        size: number;
        percent: number;
        state: "sending" | "saving" | "done" | "failed" | "unconfirmed" | "refused";
        error?: string | undefined;
    }[], PublicUpload[] | {
        name: string;
        size: number;
        percent: number;
        state: "sending" | "saving" | "done" | "failed" | "unconfirmed" | "refused";
        error?: string | undefined;
    }[]>;
    upload: (files: File[] | FileList, o?: PublicUploadOptions) => Promise<void>;
    status: Ref<PublicStatus>;
    info: Ref<PublicRequestInfo | null, PublicRequestInfo | null>;
    reason: Ref<PublicFailure>;
    pinFailure: Ref<PinFailure>;
    lockMessage: Ref<string>;
    pinBusy: Ref<boolean>;
    failure: Ref<string>;
    toast: Ref<string>;
    jobId: Ref<string>;
    /** The plugin surface on this link, when it carries one. */
    conv: PluginSurfaceStore;
    /** (Re-)read the link. `query` is appended verbatim (`?path=…`). */
    load: (query?: string) => Promise<void>;
    submitPin: (pin: string) => Promise<void>;
    /** Where the browser loads an exposed copy from (`pub:N`). */
    fileUrl: (ref: string) => string;
    /** The same copy as a download — the only fetch that counts as one. */
    fileDownloadUrl: (ref: string) => string;
    resolveFile: (ref: string) => {
        url: string;
        name?: string;
        mime?: string;
    };
    url: PublicRoot;
};

/** A share: a file, a folder, or an app plugin's page. */
export declare function usePublicShare(token: string, opts: PublicLinkOptions): {
    downloadUrl: (o?: {
        zip?: boolean;
        path?: string;
    }) => string;
    noJsUrl: () => string;
    status: Ref<PublicStatus>;
    info: Ref<PublicShareInfo | null, PublicShareInfo | null>;
    reason: Ref<PublicFailure>;
    pinFailure: Ref<PinFailure>;
    lockMessage: Ref<string>;
    pinBusy: Ref<boolean>;
    failure: Ref<string>;
    toast: Ref<string>;
    jobId: Ref<string>;
    /** The plugin surface on this link, when it carries one. */
    conv: PluginSurfaceStore;
    /** (Re-)read the link. `query` is appended verbatim (`?path=…`). */
    load: (query?: string) => Promise<void>;
    submitPin: (pin: string) => Promise<void>;
    /** Where the browser loads an exposed copy from (`pub:N`). */
    fileUrl: (ref: string) => string;
    /** The same copy as a download — the only fetch that counts as one. */
    fileDownloadUrl: (ref: string) => string;
    resolveFile: (ref: string) => {
        url: string;
        name?: string;
        mime?: string;
    };
    url: PublicRoot;
};

/**
 * The shell's and the bodies' reader. Outside a provider (a component mounted
 * on its own) the table is empty and every sentence reads as nothing.
 */
export declare function usePublicText(locale?: () => string): {
    pt: (key: string, vars?: Record<string, string | number>) => string;
    ready: ComputedRef<boolean>;
};

export declare function useReorderDrag(opts: ReorderDragOptions): ReorderDrag;

/**
 * i18n key for an event's END-USER label — the per-event switches in the user
 * settings dialog.
 *
 * ⚠ A separate catalogue on purpose, not a second spelling of the same one.
 * The switches borrowed the operator sentences for a release, and the result
 * was a list of rows explaining write semantics to somebody who had opened
 * "What to tell me about" to stop being pinged about comments. The two
 * audiences want different sentences about the same event, and one string
 * cannot be both — so the difference is stored rather than negotiated, and
 * `web/tests/webhooks/eventCatalog.test.ts` fails when an event arrives
 * without either of them.
 */
export declare function userEventKey(event: string): string;

declare interface UserSearchResponse {
    users: UserSuggestion[];
}

/** The account's own endpoints — every one of them open to every signed-in
 *  account (backend routes.go, "authenticated user routes"). */
export declare interface UserSettingsApi {
    updateProfile(patch: Partial<SettingsUser>): Promise<SettingsUser>;
    /** `POST /api/auth/account/check`: whether an address / a username would
     *  be accepted, in the server's words (lib/accountRules). Optional: a host
     *  without it checks on Save only. */
    checkAccount?(q: AccountCheckQuery): Promise<AccountCheckAnswer>;
    changePassword(current: string, next: string): Promise<void>;
    enrollTotp(): Promise<{
        secret: string;
        qr_svg: string;
        recovery_codes?: string[];
    }>;
    verifyTotp(code: string): Promise<void>;
    disableTotp(code: string): Promise<void>;
    quota(): Promise<SettingsQuota>;
    notificationSettings(): Promise<SettingsNotificationPrefs | null>;
    updateNotificationSettings(prefs: SettingsNotificationPrefs): Promise<SettingsNotificationPrefs | null>;
    /**
     * 0.50 - `GET /api/files/plugins/actions`: the app interfaces that open
     * files and the administrator's open rules, so Default apps can say which
     * of the person's choices are still available. Absent: the pane lists the
     * choices without judging them.
     */
    pluginActions?(): Promise<PluginActionsResponse>;
    /**
     * wiring:e2 vault - `GET / PUT /api/files/e2e/vault/prefs`: how long a
     * vault this person writes to stays theirs while they do nothing, in
     * minutes (1-10, 3 until set). Kept on the server for the person, not per
     * browser. Absent: the row is not drawn.
     */
    vaultIdle?(): Promise<number>;
    setVaultIdle?(minutes: number): Promise<number>;
}

/**
 * The account endpoints over the explorer's own client (`useFileApi(config)
 * .jsonFetch`): its credential, its language, its credentials mode — for a
 * host that hands the explorer a token rather than a session (the desktop app).
 * `base` is the server root (`connectionsBase(config)`).
 *
 * ⚠ The admin app does NOT use this: it passes its own axios client (the one
 * with its CSRF header and its 401 redirect), so a settings save there fails and
 * recovers exactly like every other request it makes.
 */
export declare function userSettingsApi(jsonFetch: <R>(url: string, init?: RequestInit) => Promise<R>, base: string): UserSettingsApi;

export declare const UserSettingsDialog: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (v: boolean) => any;
}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{
"onUpdate:modelValue"?: ((v: boolean) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
avatarInput: HTMLInputElement;
}, any>;

export declare interface UserSettingsHost {
    /** The language on screen — any offered code, a language pack's included. */
    readonly locale: string;
    readonly user: SettingsUser | null;
    /** The account's role is administrator — of its tenant, of the supertenant or
     *  of a single-tenant install. ⚠ Not `capabilities.caller_admin`, which is
     *  the narrower "may set the INSTANCE up" (the supertenant's alone on a
     *  multi-tenant install). It draws the account's badge, and decides who is
     *  offered the switch for a new encryption request (lib/webhookEvents). */
    readonly isAdmin: boolean;
    /** The demo account: nothing it changes may be saved. */
    readonly demoReadOnly: boolean;
    readonly capabilities: SettingsCapabilities | null;
    readonly api: UserSettingsApi;
    /** The server's answer after a profile write replaces the person. */
    setUser(user: SettingsUser): void;
    toast(kind: 'success' | 'error' | 'warn', message: string): void;
    /** A failed request, said for a person. */
    errorText(err: unknown, fallback: string): string;
    /** This person's time zone on this surface (lib/timezone accountZoneControl). */
    readonly zone: {
        get(): string;
        set(tz: string): void;
    };
    /** Light / automatic / dark — whichever store this surface paints from. */
    readonly mode: {
        get(): SettingsThemeMode;
        set(mode: SettingsThemeMode): void;
    };
    /** The interface language (the admin app). The dialog also writes it to the
     *  account, so the next device opens in it. */
    readonly language?: {
        pick(code: string): void;
    };
    /** Where the app lands after sign-in (the admin app's router). */
    readonly startPage?: {
        readonly options: string[];
        get(): string | null;
        set(page: string): void;
    };
    /** Whether one click or two opens a file. */
    readonly openTrigger?: {
        get(): 'single' | 'double';
        set(v: 'single' | 'double'): void;
    };
    /** Where to download the desktop app for this machine. */
    readonly desktopApp?: {
        readonly platform: string | null;
        readonly platformLabel: string;
        /** `other`: the same file for the other processor (x64 / arm64), drawn
         *  beside the row. The host writes every word, this dialog none. */
        readonly downloads: Array<{
            href: string;
            label: string;
            hint: string;
            arch?: string;
            other?: {
                arch: string;
                label: string;
                href: string;
            };
        }>;
        readonly releasesUrl: string;
    };
    /**
     * Installing the web app itself on this device - a phone or a tablet in a
     * browser (task #190). The permanent home of the offer the app's reminder
     * makes once, as `desktopApp` is the desktop app's.
     *
     * `state`: `prompt` - the browser offers an install, `install()` opens its
     * dialog; `ios` - Safari's Share → Add to Home Screen; `menu` - the
     * browser's own menu; `null` - nothing to offer (already installed, or a PC,
     * which is offered the desktop app). Absent or `null` → not drawn.
     */
    readonly installApp?: {
        readonly state: 'prompt' | 'ios' | 'menu' | null;
        install(): Promise<'accepted' | 'dismissed' | 'unavailable'>;
    };
    /** The browser's own notifications (the admin app in a browser tab). */
    readonly browserNotifications?: {
        readonly desktopShell: boolean;
        permission(): BrowserNotifyPermission;
        enabled(): boolean;
        setEnabled(on: boolean): void;
        ask(): Promise<BrowserNotifyPermission>;
    };
    /**
     * Push notifications on this device (#191, lib/webPush): what the bell
     * tells the person reaches this phone or browser while filex is closed.
     * Given by a host that runs filex's own service worker (the web app, in a
     * tab or installed); not by the desktop app, whose native notifications
     * already reach a closed window, nor by an explorer embedded in another
     * site, whose workers are that site's.
     */
    readonly webPush?: WebPushController;
}

declare interface UserSuggestion {
    id: number;
    email: string;
    display_name: string;
    username?: 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>;
    errorHint: 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>;
};

/**
 * The explorer's handle on the order.
 *
 * Each call re-reads this browser's mirror — a mount after a sign-out, or
 * after another tab changed it, starts from the current answer rather than
 * the last one this module happened to hold — and follows the account's
 * document while the calling component lives.
 */
export declare function useStorageOrder(): StorageOrderHandle;

/** The host's answer, or null. Must be called during `setup()`. */
export declare function useTableEnv(): TableEnv | null;

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;
    permissions?: Record<string, string> | undefined;
    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;
    permissions?: Record<string, string> | undefined;
    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>;
    setPermissions: (id: number, permissions: Record<string, string>) => Promise<boolean>;
    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>;
};

declare type Value = string | number;

declare type Vars = Record<string, string | number>;

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

/** The `viewer` views that are an app's own interface. */
export declare function viewerViews(views: readonly PluginViewRow[]): PluginViewRow[];

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

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

/** Is a transport attached? */
export declare function viewPrefsAttached(): boolean;

export declare interface ViewPrefsHttpOptions {
    /** The server's base URL, '' for same-origin. */
    apiBase?: string;
    /** Authorization and friends. May be async (the desktop app fetches its
     *  credential from the main process per call). ⚠ Awaited — a Promise spread
     *  into a headers object sends the request with no Authorization at all
     *  (filex lesson #10). */
    headers?: () => Record<string, string> | Promise<Record<string, string>>;
    credentials?: RequestCredentials;
}

export declare function viewPrefsHttpTransport(opts: ViewPrefsHttpOptions): {
    load(): Promise<unknown>;
    save(doc: unknown): void;
};

export declare function viewPrefsReady(): boolean;

/** 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. Session-only when there is nobody to save for. */
    set(value: T): void;
    /** Remove the key entirely. */
    clear(): void;
    /** Has the document been read yet? Reactive. */
    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 document. ⚠ The 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;
}

/** The fields of one form that the person may see, conditions cascaded. */
export declare function visibleFields(fields: PluginField[] | undefined, values: Record<string, unknown>): PluginField[];

/** 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[];

/** The fields of a storage-list row this reads. */
export declare interface WatchedStorageRow {
    id: number;
    running?: boolean;
    last_sync_state?: string | null;
    last_sync_error?: string | null;
}

/** The note that the person turned push on for this browser, per person. */
export declare const WEB_PUSH_NOTE_KEY = "filex.notify.push";

export declare const WEBHOOK_EVENTS: readonly ["file.uploaded", "file.updated", "file.upload_failed", "file.infected", "file.deleted", "file.trashed", "file.moved", "archive.created", "archive.extracted", "share.created", "drop.received", "comment.added", "e2e.escrow_used", "e2e.password_changed", "e2e.request_created", "e2e.request_decided", "plugin.notice", "notification.digest"];

export declare type WebhookEvent = (typeof WEBHOOK_EVENTS)[number];

/**
 * i18n key for an event's OPERATOR label — the admin webhook screen.
 *
 * These read like the log line they describe ("File updated — a write replaced
 * the bytes of an existing file"), because the person ticking the box is
 * wiring a delivery and needs to know exactly which write fires it.
 */
export declare function webhookEventKey(event: string): string;

/** The account's push endpoints (backend handlers/notification_push.go). */
export declare interface WebPushApi {
    status(): Promise<WebPushStatus>;
    subscribe(body: WebPushSubscriptionBody): Promise<WebPushDevice>;
    /** This browser, by its endpoint: push turned off on it, or signing out. */
    forget(endpoint: string): Promise<void>;
    /** One of the person's devices, by id. */
    remove(id: number): Promise<void>;
    test(): Promise<{
        sent: number;
        failed: number;
    }>;
}

export declare interface WebPushController {
    state(): Promise<WebPushState>;
    /** ⚠ From the tap and from nowhere else: it may ask for the permission. */
    enable(): Promise<WebPushState>;
    disable(): Promise<WebPushState>;
    remove(id: number): Promise<WebPushState>;
    test(): Promise<{
        sent: number;
        failed: number;
    }>;
    /** On every start of the app: keep this device's subscription true. */
    reconcile(): Promise<void>;
    /** Before signing out: this browser stops receiving the person's pushes. */
    forgetDevice(): Promise<void>;
}

/**
 * Web Push on this device (task #191) - the switch "Push notifications on this
 * device" in the user settings dialog, and what keeps it true afterwards.
 *
 * ⚠⚠ ONE flow, here, for every surface that runs filex's own service worker:
 * asking the browser's permission (from the tap), subscribing with the
 * server's key, telling the server, finding this device in the person's list,
 * turning it off, re-subscribing when the server's key was rotated or the
 * browser dropped the subscription, and forgetting the device when the person
 * signs out. A host hands over the two things only it has - its service
 * worker and its transport (`WebPushEnv`, `WebPushApi`) - and nothing else.
 * Where there is no filex worker (an explorer embedded in another site, whose
 * workers are that site's) or the platform notifies on its own (the desktop
 * app raises native notifications from its tray even with the window closed),
 * the host gives no `webPush` row and the dialog draws none.
 *
 * What is pushed, and when, is the server's: a push is one more reader of the
 * person's bell (backend internal/notify push.go) - the same kinds, the same
 * mutes, the same digest. Nothing about it is decided here.
 *
 * ⚠ iPhone and iPad: only the web app added to the Home Screen (iOS / iPadOS
 * 16.4 and later) has `PushManager`; a Safari tab has none, and the dialog
 * says where to look instead. The permission is asked FIRST in `enable()`,
 * before anything is awaited, because Safari asks only from the tap itself.
 * Every push shows a notification (`userVisibleOnly`) - the worker always
 * raises one (web/public/notify-sw.js), which iOS requires.
 *
 * Pure TypeScript, no Vue: the dialog drives it, and the web app calls it on
 * start (reconcile) and on sign-out (forgetDevice).
 */
/** One of the person's devices, as GET /api/notifications/push lists it. */
export declare interface WebPushDevice {
    id: number;
    label: string;
    /** Hex SHA-256 of the device's endpoint - how this browser finds itself. */
    endpoint_hash: string;
    /** The push service's host (fcm.googleapis.com, web.push.apple.com …). */
    service?: string;
    created_at: string;
    last_ok_at?: string | null;
}

/** What only the host has. */
export declare interface WebPushEnv {
    /** The person signed in (the "on for this device" note is kept per person). */
    userId: number | null;
    /** The host's own service worker, the one the pushes arrive at. */
    registration(): Promise<ServiceWorkerRegistration | null>;
    /** The browser's Notification API. Default: `window.Notification`. */
    notification?: WebPushNotificationApi | null;
    /** Whether this browser has Web Push at all. Default: `PushManager` exists. */
    supported?: () => boolean;
    /** Where the note is kept. Default: localStorage. */
    storage?: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'> | null;
    /** The browser, for the device's label. Default: navigator.userAgent. */
    userAgent?: string;
    /** Hex SHA-256 of a text. Default: crypto.subtle. */
    sha256?: (text: string) => Promise<string>;
}

/** What the browser's Notification API gives (`window.Notification`). */
export declare interface WebPushNotificationApi {
    readonly permission: NotificationPermission;
    requestPermission(): Promise<NotificationPermission> | void;
}

export declare type WebPushPermission = 'granted' | 'denied' | 'default' | 'unsupported';

/** What the dialog draws. */
export declare interface WebPushState {
    /** This browser can receive pushes at all. */
    supported: boolean;
    permission: WebPushPermission;
    /** The server's answer; null when it could not be asked. */
    status: WebPushStatus | null;
    /** This browser receives pushes for this person. */
    on: boolean;
    /** This browser in `status.devices`, by id. */
    thisDevice: number | null;
}

/** GET /api/notifications/push. */
export declare interface WebPushStatus {
    available: boolean;
    /** Why not: `disabled`, `no_secret_key`, `key_unreadable`, `error`. */
    reason?: string;
    /** The server's key (base64url): what a browser subscribes with. */
    public_key?: string;
    devices: WebPushDevice[];
}

/** What a browser hands the server: PushSubscription.toJSON() and a name. */
export declare interface WebPushSubscriptionBody {
    endpoint: string;
    keys: {
        p256dh: string;
        auth: string;
    };
    label: string;
}

/** Anything a date arrives as: epoch seconds or milliseconds, an ISO string,
 *  a Date. Null for nothing or for something that is not an instant. */
export declare type WhenInput = number | string | Date | null | undefined;

export declare function widthsAreAuto(): boolean;

/**
 * An application path (`/files/edit`, `/api/files/archive/list`) as the
 * browser has to ask for it from this document: with the base in front.
 */
export declare function withAppBase(path: string): string;

/** One field's face changed (the signer picked another one from the field's own picker). */
export declare function withFont(fields: PdfField[], id: string, font: SignFontKey): PdfField[];

/** `raw` with its prefix replaced by `prefix` ('' takes it off). */
export declare function withPanelPrefix(raw: string, prefix: string): string;

/**
 * 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 { }