@brftech/filex-core 0.1.56

package/dist/index.d.ts

@@ -0,0 +1,1089 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { CreateComponentPublicInstanceWithMixins } from 'vue';
+import { DefineComponent } from 'vue';
+import { GlobalComponents } from 'vue';
+import { GlobalDirectives } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+
+declare type __VLS_Props = {
+    config: ExplorerConfig;
+};
+
+declare type __VLS_Props_2 = {
+    open: boolean;
+    locale: LocaleCode;
+    file: FileNode | null;
+    previewUrl: (path: string) => string;
+    downloadUrl: (path: string) => string;
+    onlyOfficeBase?: string | null;
+    onlyOfficeConfigEndpoint?: string | null;
+    saveTextEndpoint?: string | null;
+    openMode?: 'edit' | 'view';
+    authHeaders?: () => 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;
+    /** 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';
+};
+
+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>>;
+    /** Compact mode for grid view (no label, just the icon). */
+    compact?: boolean;
+};
+
+declare type __VLS_Props_4 = {
+    nodeId: number;
+    apiBase?: string;
+    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+    /** Optional list of palette swatches; one is picked per tag deterministically. */
+    palette?: string[];
+};
+
+declare type __VLS_Props_5 = {
+    apiBase?: string;
+    authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+    limit?: number;
+    /** Optional refresh trigger — incrementing this re-fetches. */
+    refreshKey?: number | string;
+};
+
+export declare interface ArchiveEntry {
+    name: string;
+    size: number;
+    isDir: boolean;
+    lastModified?: number;
+}
+
+/**
+ * ExplorerConfig — props passed to the FileExplorer component.
+ *
+ * Two equivalent ways to wire it up:
+ *
+ *   1. New clean API (preferred — RESTful, server-agnostic):
+ *      { apiBase: 'https://files.example.com', auth: { kind: 'bearer', token } }
+ *      → URLs like `${apiBase}/api/files/manager`, `${apiBase}/api/files/upload/init`.
+ *
+ *   2. Legacy API (Vuefinder-compat — for embedders that mounted the
+ *      old `@brftech/file-explorer` package against their own routes):
+ *      { endpoint: '/api/files/manager', uploadInit: '/api/files/upload/init', … }
+ *      → caller fully controls every URL.
+ *
+ * If both `apiBase` AND any explicit `endpoint`/`uploadInit`/etc. are
+ * present, the explicit field wins (lets you override one route while
+ * keeping the auto-derived rest).
+ */
+/**
+ * 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;
+};
+
+export declare interface Capabilities {
+    ffmpeg?: boolean;
+    ghostscript?: boolean;
+    libreoffice?: boolean;
+    onlyoffice_url?: string | null;
+    drawio_url?: string | null;
+    convert_url?: string | null;
+    max_chunk_mb?: number;
+    upload_limit_mb?: number;
+    external?: {
+        onlyoffice?: ExternalServiceStatus;
+        drawio?: ExternalServiceStatus;
+        mermaid?: ExternalServiceStatus;
+    };
+}
+
+export declare interface ClipboardState {
+    mode: 'cut' | 'copy' | null;
+    items: FileNode[];
+    sourcePath: string | null;
+}
+
+declare interface ContextAction {
+    key: string;
+    label: string;
+    icon?: string;
+    danger?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    divider?: boolean;
+}
+
+/** English UI strings. */
+export declare const en: Record<string, string>;
+
+/**
+ * Resolved endpoint map. `useFileApi` derives this once on construction
+ * — components never need to think about config/apiBase precedence.
+ */
+export declare interface EndpointMap {
+    manager: string;
+    uploadInit: string | null;
+    uploadFinalize: string | null;
+    uploadAbort: string | null;
+    shareCreate: string | null;
+    shareList: string | null;
+    shareDelete: string | null;
+    limits: string | null;
+    capabilities: string | null;
+    archiveList: string | null;
+    archiveExtract: string | null;
+    archiveAdd: string | null;
+    copy: string | null;
+    moveAsync: string | null;
+    deleteAsync: string | null;
+    opsList: string | null;
+    opsShow: string | null;
+    onlyOfficeConfig: string | null;
+    saveText: string | null;
+    restore: string | null;
+    trashList: string | null;
+    trashRestore: string | null;
+}
+
+export declare function ensureHighlight(): Promise<unknown | null>;
+
+/**
+ * Resolve Monaco. If preload hasn't been kicked off yet, this triggers
+ * it (and pays the load cost on the spot). Returns `null` when the
+ * package isn't installed.
+ */
+export declare function ensureMonaco(): Promise<unknown | null>;
+
+export declare interface ExplorerConfig {
+    /**
+     * Modern shorthand: URL prefix for the standard /api/files/* layout.
+     * Example: `https://files.example.com` → `${apiBase}/api/files/manager`,
+     * `${apiBase}/api/files/upload/init`, etc. Any explicit endpoint*
+     * field below overrides the derived URL.
+     */
+    apiBase?: string;
+    /** Legacy main endpoint (Vuefinder-compat: GET/POST `?q=…`). */
+    endpoint?: string;
+    uploadInit?: string;
+    uploadFinalize?: string;
+    uploadAbort?: string;
+    shareCreate?: string;
+    shareList?: string;
+    /** DELETE template; `{uuid}` placeholder is replaced at call time. */
+    shareDelete?: string;
+    limits?: string;
+    capabilities?: string;
+    archiveList?: string;
+    archiveExtract?: string;
+    archiveAdd?: string;
+    /** Recursive S3-side copy with "-copy" collision suffix (async). */
+    copy?: string;
+    /** Async move endpoint — returns {op}, client polls /opsList. */
+    moveAsync?: string;
+    /** Async delete endpoint — returns {op}, client polls /opsList. */
+    deleteAsync?: string;
+    /** Pending ops list endpoint (poll target). */
+    opsList?: string;
+    /** Single op show endpoint — `{id}` placeholder. */
+    opsShow?: string;
+    /**
+     * OnlyOffice config endpoint. Backend POST returns
+     * `{ config, documentServerUrl }` where `config` is a JWT-signed
+     * DocEditor config. PreviewModal mounts the editor against this
+     * when the user opens an office file with mode=edit.
+     */
+    onlyOfficeConfig?: string;
+    /**
+     * Standalone editor page base — when set, "Aç" 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;
+    /** Public share base URL — `${shareBase}/${uuid}` */
+    shareBase?: string;
+    /** Auth strategy (see AuthConfig). */
+    auth?: AuthConfig;
+    /** Show the virtual `.trash/` entry in the root listing. */
+    trashVisible?: boolean;
+    /** UI dil kodu */
+    locale?: LocaleCode;
+    /** OnlyOffice iframe base (e.g. `https://docs.example.com`). */
+    onlyOfficeBase?: string;
+    /** Drawio iframe base. */
+    drawioBase?: string;
+    /** Universal converter (p2r3/convert fork) iframe base, e.g. `https://fm.example.com/convert`. */
+    convertBase?: string;
+    /**
+     * Drawio embed URL (full URL to the embed endpoint). Defaults to
+     * `https://embed.diagrams.net`. The DrawioViewer iframes this with
+     * `?embed=1&proto=json` postMessage handshake to load + save XML.
+     */
+    drawioUrl?: string;
+    /**
+     * Optional URL where serialized PDF annotations / form data is
+     * persisted. POST `{ path, base64 }` — the rich PdfViewer uses
+     * `pdf.saveDocument()` and forwards the saved bytes here when the
+     * user clicks the save annotation button.
+     */
+    pdfSaveUrl?: string;
+    /**
+     * Override the pdf.js worker URL. Defaults to a CDN copy matching
+     * the version pdfjs-dist resolves to at runtime — hosts can pin
+     * their own self-hosted worker for CSP-strict environments.
+     */
+    pdfWorkerUrl?: string;
+    /**
+     * Standalone full-screen viewer route. The PreviewModal toolbar's
+     * "Open in new tab" button navigates to
+     * `${viewerBaseUrl}?path=…&storage=…&type=…`. The consumer wires
+     * that route to mount the same viewer fullscreen (admin UI / fishapp
+     * embed). Defaults to `/files/viewer`.
+     */
+    viewerBaseUrl?: string;
+    /** Upload chunk size (bytes). Default 5 MB. */
+    chunkSize?: number;
+    /** Parallel chunks. Default 4. */
+    parallelChunks?: number;
+    /** Theme. */
+    theme?: ThemeMode;
+    /** Initial path (storage-prefix included: `local://`). Default: root. */
+    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;
+    /** Whether the info panel toggle is visible. */
+    showInfoPanel?: boolean;
+    /** Default view. */
+    viewMode?: 'list' | 'grid';
+    /** Override max upload size (MB) — falls back to /limits otherwise. */
+    maxFileSizeMb?: number;
+    /** Accept patterns (MIME or extension). Empty = unrestricted. */
+    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).
+     *   'none'         — don't persist. Embedder controls path externally.
+     */
+    pathPersist?: '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 "/".
+     */
+    storages?: Array<{
+        name: string;
+        label?: string;
+        driver?: string;
+        readOnly?: boolean;
+    }>;
+}
+
+/** Component emits — the parent listens for these events. */
+export declare interface ExplorerEmits {
+    'share-created': (payload: {
+        path: string;
+        url: string;
+        pin: string | null;
+    }) => void;
+    'file-opened': (file: {
+        path: string;
+        basename: string;
+    }) => void;
+    error: (err: {
+        message: string;
+        context?: unknown;
+    }) => void;
+    'upload-progress': (p: {
+        uploadId: string;
+        percent: number;
+        done: boolean;
+    }) => void;
+    'selection-change': (items: Array<{
+        path: string;
+        basename: string;
+        type: 'file' | 'dir';
+    }>) => void;
+}
+
+export declare type ExternalServiceState = 'ok' | 'error' | 'disabled' | 'unknown';
+
+export declare interface ExternalServiceStatus {
+    enabled: boolean;
+    state: ExternalServiceState;
+    url?: string;
+    last_check?: string;
+    detail?: string;
+}
+
+export declare type FileApi = ReturnType<typeof useFileApi>;
+
+export declare const FileExplorer: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+error: (err: {
+message: string;
+context?: unknown;
+}) => any;
+"share-created": (payload: {
+path: string;
+url: string;
+pin: string | null;
+}) => any;
+"file-opened": (file: {
+path: string;
+basename: string;
+}) => any;
+"upload-progress": (p: {
+uploadId: string;
+percent: number;
+done: boolean;
+}) => any;
+"selection-change": (items: {
+path: string;
+basename: string;
+type: "file" | "dir";
+}[]) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+onError?: ((err: {
+message: string;
+context?: unknown;
+}) => any) | undefined;
+"onShare-created"?: ((payload: {
+path: string;
+url: string;
+pin: string | null;
+}) => any) | undefined;
+"onFile-opened"?: ((file: {
+path: string;
+basename: string;
+}) => any) | undefined;
+"onUpload-progress"?: ((p: {
+uploadId: string;
+percent: number;
+done: boolean;
+}) => any) | undefined;
+"onSelection-change"?: ((items: {
+path: string;
+basename: string;
+type: "file" | "dir";
+}[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+rootEl: HTMLDivElement;
+toolbarRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+viewMode: ViewMode;
+searchQuery: string;
+trashActive: boolean;
+actions: ContextAction[];
+selectionMode?: SelectionMode_2;
+pasteEnabled?: boolean;
+convertEnabled?: boolean;
+canGoUp?: boolean;
+atVirtualRoot?: boolean;
+canWrite?: boolean;
+locale: LocaleCode;
+}> & Readonly<{
+onAction?: ((key: string) => any) | undefined;
+onUpload?: (() => any) | undefined;
+"onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
+"onUpdate:searchQuery"?: ((v: string) => any) | undefined;
+"onNew-folder"?: (() => any) | undefined;
+onRefresh?: (() => any) | undefined;
+"onGo-up"?: (() => any) | undefined;
+"onOpen-recents"?: (() => any) | undefined;
+}>, {
+focusSearch: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+action: (key: string) => any;
+upload: () => any;
+"update:viewMode": (v: ViewMode) => any;
+"update:searchQuery": (v: string) => any;
+"new-folder": () => any;
+refresh: () => any;
+"go-up": () => any;
+"open-recents": () => any;
+}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+searchEl: HTMLInputElement;
+}, HTMLDivElement, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{
+viewMode: ViewMode;
+searchQuery: string;
+trashActive: boolean;
+actions: ContextAction[];
+selectionMode?: SelectionMode_2;
+pasteEnabled?: boolean;
+convertEnabled?: boolean;
+canGoUp?: boolean;
+atVirtualRoot?: boolean;
+canWrite?: boolean;
+locale: LocaleCode;
+}> & Readonly<{
+onAction?: ((key: string) => any) | undefined;
+onUpload?: (() => any) | undefined;
+"onUpdate:viewMode"?: ((v: ViewMode) => any) | undefined;
+"onUpdate:searchQuery"?: ((v: string) => any) | undefined;
+"onNew-folder"?: (() => any) | undefined;
+onRefresh?: (() => any) | undefined;
+"onGo-up"?: (() => any) | undefined;
+"onOpen-recents"?: (() => any) | undefined;
+}>, {
+focusSearch: () => void;
+}, {}, {}, {}, {}> | null;
+ctxRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+locale: LocaleCode;
+actions: ContextAction[];
+theme?: ThemeMode;
+}> & 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, {
+menuEl: HTMLDivElement;
+}, any, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{
+locale: LocaleCode;
+actions: ContextAction[];
+theme?: ThemeMode;
+}> & Readonly<{
+onSelect?: ((action: ContextAction, target: FileNode[]) => any) | undefined;
+}>, {
+show: (ev: {
+clientX: number;
+clientY: number;
+}, nodes: FileNode[]) => Promise<void>;
+hide: () => void;
+}, {}, {}, {}, {}> | null;
+fileInputEl: HTMLInputElement;
+}, HTMLDivElement>;
+
+/**
+ * FileNode — node shape returned by the manager endpoint.
+ *
+ * Backend `?q=index` (or `GET /api/files/manager?action=index`) returns:
+ *   { adapter, storages, dirname, files: FileNode[] }
+ */
+export declare interface FileNode {
+    /** DB node ID — needed by the per-user meta routes (starred, tags,
+     *  recently-opened). Backend's projectFileNodes() emits it for every
+     *  row; only client-synthesized rows (e.g. multi-storage virtual
+     *  folders) lack one. */
+    id?: number;
+    /** Full adapter-qualified path: `local://receipts/2024/invoice.pdf` */
+    path: string;
+    /** Relative basename: `invoice.pdf` */
+    basename: string;
+    /** Adapter-stripped relative path: `receipts/2024/invoice.pdf` */
+    relativePath?: string;
+    /** `file` or `dir` */
+    type: 'file' | 'dir';
+    /** Extension (lowercased, no dot). Empty string = no extension. */
+    extension?: string;
+    /** Bytes. 0 = directory. */
+    size?: number;
+    /** Unix ms (backend "last_modified"). */
+    last_modified?: number;
+    /** MIME. */
+    mime_type?: string;
+    /** Optional thumbnail URL (backend may inline). */
+    thumb_url?: string | null;
+    /** Visibility: private | public. */
+    visibility?: 'private' | 'public';
+    /** File count for directories. */
+    count?: number;
+    /** Client-side tag (localStorage or backend). */
+    starred?: boolean;
+    /** Hex color tag. */
+    color?: string | null;
+    /** Server-side trash marker. */
+    trashed?: boolean;
+    /** RBAC effective level for the current user on this entry (backend
+     *  projectFileNodes emits it when a storage has RBAC on). '' / undefined =
+     *  ACL not enforced. Used to gate edit/manage affordances client-side. */
+    perm?: 'none' | 'viewer' | 'editor' | 'owner';
+    /** Generic — any additional fields the backend wants to inline. */
+    [k: string]: unknown;
+}
+
+export declare function getHighlight(): unknown | null;
+
+/** Synchronous cached lookup — null if Monaco not yet ready or absent. */
+export declare function getMonaco(): unknown | null;
+
+/** A single ACL grant row (RBAC permissions panel). */
+declare interface Grant {
+    id: number;
+    storage_id: number;
+    path_prefix: string;
+    user_id: number;
+    level: 'viewer' | 'editor' | 'owner';
+    user_email?: string;
+    user_display_name?: string;
+    inherited?: boolean;
+}
+
+declare interface InviteResponse {
+    mode: 'granted' | 'user_created' | 'shared';
+    user_id?: number;
+    url?: string;
+    temp_password?: string;
+    emailed: 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;
+
+export declare type LocaleCode = 'tr' | 'en';
+
+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';
+    files: FileNode[];
+}
+
+export declare const messages: Record<LocaleCode, Record<string, string>>;
+
+export declare interface PendingOp {
+    id: number;
+    op_type: 'copy' | 'move' | 'delete';
+    status: 'pending' | 'running' | 'done' | 'error';
+    progress_total: number;
+    progress_done: number;
+    target_path: string | null;
+    source_dir: string | null;
+    source_count: number;
+    error_message: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    created_at: string | null;
+}
+
+/** Server-side PendingOp DTO (mirror of Modules\FishApp\Models\PendingOp::toApiArray). */
+export declare interface PendingOpDto {
+    id: number;
+    op_type: 'copy' | 'move' | 'delete';
+    status: 'pending' | 'running' | 'done' | 'error';
+    progress_total: number;
+    progress_done: number;
+    target_path: string | null;
+    source_dir: string | null;
+    source_count: number;
+    error_message: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    created_at: string | null;
+}
+
+declare interface PermissionsResponse {
+    path: string;
+    storage_rbac: boolean;
+    direct: Grant[];
+    inherited: Grant[];
+    effective: string;
+}
+
+/**
+ * useMonacoLoader — fire-and-forget Monaco preloader.
+ *
+ * The preview/edit flow wants Monaco when available (best-in-class
+ * editor) and highlight.js for read-only syntax colour as a graceful
+ * fallback. Monaco is heavy (~5 MB), so we kick off the dynamic import
+ * at module-init time — by the time the user clicks "edit" on a code
+ * file (typically several seconds in), the chunk is already cached.
+ *
+ *   - `monacoPromise`     resolves to the Monaco namespace, or `null`
+ *                         if the package is not installed (peer
+ *                         missing) / load fails.
+ *   - `highlightPromise`  resolves to the highlight.js export, or
+ *                         `null` similarly.
+ *   - `getMonaco()`       returns the cached module synchronously
+ *                         (after `await monacoPromise`) so a click
+ *                         handler doesn't re-trigger the import.
+ *
+ * Both modules are externalized in the bundler config — the consumer
+ * either declares them as direct deps (Monaco UX) or doesn't (the
+ * highlight.js read-only path takes over). No build-time hard dep here.
+ */
+/**
+ * Kick off the Monaco import the first time someone calls
+ * `preloadEditor()` (typically the FileExplorer onMounted hook). Cheap
+ * to call repeatedly — only the first call actually triggers the
+ * dynamic import.
+ */
+export declare function preloadEditor(): void;
+
+export declare const PreviewModal: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+close: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
+onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+markdownEl: HTMLDivElement;
+monacoEl: HTMLDivElement;
+officeEl: HTMLDivElement;
+}, any>;
+
+export declare const RecentlyOpened: DefineComponent<__VLS_Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+error: (message: string) => any;
+open: (node: RecentNode) => any;
+}, string, PublicProps, Readonly<__VLS_Props_5> & Readonly<{
+onError?: ((message: string) => any) | undefined;
+onOpen?: ((node: RecentNode) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare interface RecentNode {
+    id: number;
+    storage_id: number;
+    path: string;
+    name: string;
+    mime?: string;
+    last_opened?: string;
+}
+
+declare interface ResolveEmailResponse {
+    found: boolean;
+    user?: {
+        id: number;
+        email: string;
+        display_name: string;
+        role: string;
+    };
+}
+
+/**
+ * Resolve a Vuefinder-compatible endpoint map from the user's config.
+ * Either `apiBase` is set (auto-derive everything) or each route is
+ * supplied explicitly (legacy). Mixed mode works too — explicit fields
+ * trump the derived URL.
+ */
+export declare function resolveEndpoints(config: ExplorerConfig): EndpointMap;
+
+declare type SelectionMode_2 = 'none' | 'single-file' | 'single-dir' | 'multi';
+
+export declare interface ShareInfo {
+    uuid: string;
+    url: string;
+    password_pin?: string | null;
+    expires_at?: string | null;
+    max_downloads?: number | null;
+    downloads?: number;
+    created_at?: string;
+}
+
+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;
+    hasSelection?: () => boolean;
+}
+
+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>;
+
+export declare const TagPicker: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+error: (message: string) => any;
+change: (tags: string[]) => any;
+}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
+onError?: ((message: string) => any) | undefined;
+onChange?: ((tags: string[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare type ThemeMode = 'light' | 'dark' | 'auto';
+
+/** Turkish UI strings. */
+export declare const tr: Record<string, 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;
+}
+
+export declare interface UploadFinalizeResponse {
+    s3Key: string;
+    url?: string;
+}
+
+export declare interface UploadInitResponse {
+    uploadId: string;
+    parts: Array<{
+        partNumber: number;
+        presignedUrl: string;
+    }>;
+    expiresAt: string;
+    s3Key?: string;
+}
+
+export declare interface UploadJob {
+    id: string;
+    file: File;
+    path: string;
+    uploadId?: string;
+    totalBytes: number;
+    uploadedBytes: number;
+    percent: number;
+    status: 'pending' | 'initializing' | 'uploading' | 'finalizing' | 'done' | 'error' | 'aborted';
+    error?: string;
+    cancel(): void;
+}
+
+export declare interface UploadLimits {
+    max_upload_mb: number;
+}
+
+export declare interface UploadOptions {
+    path: string;
+    file: File;
+    chunkSize?: number;
+    parallelChunks?: number;
+    onProgress?: (job: UploadJob) => void;
+    onDone?: (job: UploadJob, result: UploadFinalizeResponse) => void;
+    onError?: (job: UploadJob, err: Error) => void;
+}
+
+export declare function useFileApi(config: ExplorerConfig): {
+    index: (path: string) => Promise<ManagerResponse>;
+    search: (path: string, filter: string) => Promise<ManagerResponse>;
+    subfolders: (path: string) => Promise<{
+        folders: FileNode[];
+    }>;
+    newFolder: (path: string, name: string) => Promise<ManagerResponse>;
+    rename: (path: string, item: string, name: string) => Promise<ManagerResponse>;
+    move: (path: string, items: string[], target: string) => Promise<ManagerResponse>;
+    copy: (source: string[], target: string) => Promise<{
+        op: PendingOpDto;
+    }>;
+    moveAsync: (source: string[], target: string, sourceDir?: string) => Promise<{
+        op: PendingOpDto;
+    }>;
+    deleteAsync: (source: string[], sourceDir?: string) => Promise<{
+        op: PendingOpDto;
+    }>;
+    deleteItems: (path: string, items: string[]) => Promise<ManagerResponse>;
+    restore: (source: string[]) => Promise<{
+        ok: boolean;
+        restored: number;
+    }>;
+    listTrash: (storageName?: string) => Promise<{
+        entries: TrashEntry[];
+        total: number;
+    }>;
+    restoreIds: (ids: number[]) => Promise<{
+        restored: number;
+    }>;
+    uploadMultipart: (path: string, files: File[], onProgress?: (p: number) => void) => Promise<ManagerResponse>;
+    downloadUrl: (path: string) => string;
+    previewUrl: (path: string) => string;
+    fetchBlob: (path: string) => Promise<{
+        url: string;
+        blob: Blob;
+        mime: string;
+    }>;
+    fetchArrayBuffer: (path: string) => Promise<ArrayBuffer>;
+    limits: () => Promise<UploadLimits>;
+    capabilities: () => Promise<Capabilities>;
+    createShare: (payload: {
+        path: string;
+        password?: boolean;
+        expires_at?: string | null;
+        max_downloads?: number | null;
+        kind?: string;
+        max_uploads?: number | null;
+        drop_settings?: Record<string, unknown> | null;
+    }) => Promise<{
+        share: ShareInfo & {
+            url: string;
+            path: string;
+            filename: string;
+            kind?: string;
+        };
+    }>;
+    listShares: (path: string) => Promise<{
+        shares: ShareInfo[];
+    }>;
+    revokeShare: (uuid: string) => Promise<{
+        success: boolean;
+    }>;
+    archiveList: (path: string) => Promise<{
+        entries: ArchiveEntry[];
+    }>;
+    archiveExtract: (path: string, members?: string[]) => Promise<{
+        keys: string[];
+        count: number;
+    }>;
+    archiveAdd: (path: string, files: Array<{
+        name: string;
+        source: string;
+    }>) => Promise<{
+        path: string;
+    }>;
+    listPermissions: (path: string) => Promise<PermissionsResponse>;
+    resolveEmail: (email: string) => Promise<ResolveEmailResponse>;
+    searchUsers: (q: string) => Promise<UserSearchResponse>;
+    addPermission: (body: {
+        path: string;
+        user_id: number;
+        level: string;
+        is_dir?: boolean;
+    }) => Promise<unknown>;
+    updatePermission: (id: number, level: string) => Promise<unknown>;
+    deletePermission: (id: number) => Promise<unknown>;
+    invitePermission: (body: {
+        path: string;
+        email: string;
+        level: string;
+        create_user?: boolean;
+        role?: string;
+        is_dir?: boolean;
+        locale?: string;
+    }) => Promise<InviteResponse>;
+    shareMail: (body: {
+        path: string;
+        email?: string;
+        emails?: string[];
+        url: string;
+        pin?: string | null;
+        expires_days?: number;
+        locale?: string;
+        is_dir?: boolean;
+        size?: number;
+        mode?: string;
+    }) => Promise<{
+        emailed: boolean;
+        sent?: string[];
+        failed?: string[];
+    }>;
+    endpoints: EndpointMap;
+    authHeaders: (extra?: Record<string, string>) => Promise<Record<string, string>>;
+    authHeadersSync: (extra?: Record<string, string>) => Record<string, string>;
+    credentialsMode: () => RequestCredentials;
+    jsonFetch: <T>(url: string, init?: RequestInit) => Promise<T>;
+};
+
+export declare function useKeyboardShortcuts(rootEl: Ref<HTMLElement | null>, handlers: ShortcutHandlers): void;
+
+export declare function useLocale(localeRef: Ref<LocaleCode> | (() => LocaleCode)): {
+    t: (key: string, vars?: Record<string, string | number>) => string;
+    formatSize: (bytes: number | undefined | null) => string;
+    nodeDisplayName: (node: {
+        basename: string;
+    }) => string;
+};
+
+/**
+ * Composable wrapper — components that want reactive "is Monaco ready
+ * yet?" semantics can read the resolved promise. The implementation is
+ * intentionally tiny: components don't need anything fancier than
+ * `await ensureMonaco()` inside the click handler.
+ */
+export declare function useMonacoLoader(): {
+    ensureMonaco: typeof ensureMonaco;
+    ensureHighlight: typeof ensureHighlight;
+    getMonaco: typeof getMonaco;
+    getHighlight: typeof getHighlight;
+};
+
+export declare function usePendingOps(config: ExplorerConfig, api: FileApi, opts?: UsePendingOpsOptions): {
+    ops: Ref<    {
+    id: number;
+    op_type: "copy" | "move" | "delete";
+    status: "pending" | "running" | "done" | "error";
+    progress_total: number;
+    progress_done: number;
+    target_path: string | null;
+    source_dir: string | null;
+    source_count: number;
+    error_message: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    created_at: string | null;
+    }[], PendingOp[] | {
+    id: number;
+    op_type: "copy" | "move" | "delete";
+    status: "pending" | "running" | "done" | "error";
+    progress_total: number;
+    progress_done: number;
+    target_path: string | null;
+    source_dir: string | null;
+    source_count: number;
+    error_message: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    created_at: string | null;
+    }[]>;
+    hasActive: ComputedRef<boolean>;
+    register: (raw: PendingOp | Record<string, unknown>) => void;
+    dismiss: (id: number) => void;
+    poll: () => Promise<void>;
+    startPolling: () => void;
+    stopPolling: () => void;
+};
+
+export declare interface UsePendingOpsOptions {
+    /** Called once an op flips into a terminal state (done|error). */
+    onSettled?: (op: PendingOp) => void;
+}
+
+declare interface UserSearchResponse {
+    users: UserSuggestion[];
+}
+
+declare interface UserSuggestion {
+    id: number;
+    email: string;
+    display_name: string;
+    role: string;
+}
+
+export declare function 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[]>;
+};
+
+export declare function useUploadChunked(config: ExplorerConfig, api: FileApi): {
+    uploadFile: (opts: UploadOptions) => Promise<UploadFinalizeResponse>;
+};
+
+export declare type ViewMode = 'list' | 'grid';
+
+export { }