@useupup/core 3.3.0

package/dist/internal.d.ts

@@ -0,0 +1,595 @@
+import { d as CoreOptions, I as ImageEditorOptions, b as CloudDrivesConfig, R as ResolvedImageEditorOptions, U as UpupCore } from './core-141335ac.js';
+export { C as CoreEvents, j as CrashRecoveryManager, E as EventEmitter, i as FileManager, k as IndexedDBStorage, o as PREVIEW_MAX_TEXT_SIZE, p as PREVIEW_TEXT_TRUNCATE_LENGTH, l as PersistentStorage, P as PluginManager, m as bytesToSize, n as checkFileSize, u as fileCanPreviewText, v as fileGetExtension, q as fileGetIsImage, r as fileGetIsPdf, t as fileGetIsText, w as fileIs3D, x as searchDriveFiles, s as sizeToBytes } from './core-141335ac.js';
+export { PipelineEngine } from './pipeline/index.js';
+export { D as DirectUpload, T as TokenEndpointCredentials } from './token-endpoint-5fdb4a35.js';
+import { m as RuntimeAdapter, h as UploadResult, k as CredentialStrategy, l as UploadStrategy, R as ResumableUploadOptions, M as MaxFileSizeObject } from './contracts-strategies-378a16b7.js';
+export { j as CloudProvider, F as FileMetadata, i as ProgressInfo, U as UploadCredentials } from './contracts-strategies-378a16b7.js';
+import { a as UploadFile, F as FileSource, c as UploadStatus } from './contracts-pipeline-cf177270.js';
+import { O as OrchestratorCallbacks, U as UploaderOrchestrator } from './context-shapes-27b24c8f.js';
+export { g as BaseContextEditor, d as BaseContextFiles, c as BaseContextI18n, a as BaseContextRuntime, b as BaseContextSource, h as BaseContextTheme, B as BaseContextUpload, e as BaseContextUploadControls, f as BaseContextView, i as OrchestratorState, j as UploadProgressInfo } from './context-shapes-27b24c8f.js';
+import { L as LocaleBundle, P as PartialMessages, T as Translator, d as UiTranslations, c as Translations } from './ui-translations-c5d00392.js';
+export { F as FlatMessageKey, M as MessageNamespace } from './ui-translations-c5d00392.js';
+import { f as UpupThemeConfig } from './vars-d3421f6c.js';
+export { D as DeepPartial, l as DeepPartialSlots, I as InternalFlatClassNames, g as UpupResolvedTheme, i as tokensToVarRefs } from './vars-d3421f6c.js';
+import { a as ThemeStore } from './theme-store-f13e0315.js';
+export { T as ThemeStoreState } from './theme-store-f13e0315.js';
+import { h as ObservableController, D as DriveUser, d as DriveFolder, a as DriveFile, f as DriveBrowserError, k as DriveProviderDescriptor } from './server-mode-drive-controller-b5f8ee12.js';
+export { p as DriveAuthKind, q as DriveFolderKey, r as DriveSelectFolderStrategy, n as ServerDriveSnapshot, m as ServerDriveTransferResult, l as ServerModeDriveController, o as ServerModeDriveDeps } from './server-mode-drive-controller-b5f8ee12.js';
+export { b as buildFallbackChain, r as resolveMessage } from './resolve-locale-81feef21.js';
+import { ClassValue } from 'clsx';
+
+declare const BrowserRuntime: RuntimeAdapter;
+
+interface UploadManagerOptions {
+    credentials: CredentialStrategy;
+    uploadStrategy: UploadStrategy;
+    resolveUploadStrategy?: (file: UploadFile) => {
+        uploadStrategy: UploadStrategy;
+        presign: boolean;
+    };
+    maxConcurrentUploads: number;
+    maxRetries?: number;
+    fastAbortThreshold?: number;
+    isSuccessfulCall?: (response: {
+        status: number;
+        headers: Record<string, string>;
+        body: unknown;
+    }) => boolean | Promise<boolean>;
+    onProgress: (fileId: string, loaded: number, total: number) => void;
+    onFileStart?: (file: UploadFile) => void;
+    onFileComplete: (file: UploadFile, result: UploadResult) => void;
+    onFileError?: (file: UploadFile, error: Error) => void;
+}
+declare class UploadManager {
+    private abortController;
+    private options;
+    constructor(options: UploadManagerOptions);
+    uploadAll(files: UploadFile[]): Promise<UploadResult[]>;
+    private checkAborted;
+    private uploadFile;
+    abort(): void;
+    pause(): void;
+}
+
+type OnMessage = (data: Record<string, unknown>) => void;
+type OnError = (error: Error) => void;
+declare class SSEProcessor {
+    private sources;
+    private timers;
+    subscribe(key: string, endpoint: string, onMessage: OnMessage, onError: OnError, timeout?: number): void;
+    unsubscribe(key: string): void;
+    destroy(): void;
+}
+
+declare function getDir(locale: string | LocaleBundle | undefined): 'ltr' | 'rtl';
+declare function normalizeSource(source: string): FileSource | undefined;
+declare const DEFAULT_SOURCES: FileSource[];
+declare const DEFAULT_MAX_FILE_SIZE: {
+    size: number;
+    unit: "GB";
+};
+
+type MotionMode = 'on' | 'off';
+interface MotionGateParams {
+    /** The public `animations` prop. Default true. */
+    animations: boolean | undefined;
+    /** Injectable for tests/SSR; defaults to window.matchMedia when present. */
+    matchMedia?: ((query: string) => {
+        matches: boolean;
+        addEventListener(type: 'change', cb: (e: {
+            matches: boolean;
+        }) => void): void;
+        removeEventListener(type: 'change', cb: (e: {
+            matches: boolean;
+        }) => void): void;
+    }) | undefined;
+}
+type MotionGate = ObservableController<MotionMode>;
+/**
+ * Resolves the ONE `data-motion` value: off when the consumer opted out
+ * (`animations={false}`) OR the OS asks for reduced motion. Frameworks write
+ * the snapshot onto the uploader-panel element and re-write it on change.
+ */
+declare function createMotionGate({ animations, matchMedia, }: MotionGateParams): MotionGate;
+
+interface TransientUiSnapshot {
+    /** File ids currently playing their exit animation (render upup-fx-exit). */
+    leavingFileIds: ReadonlySet<string>;
+    /** Add-more overlay: source view mounted above the dimmed file list. */
+    sourceOverlayOpen: boolean;
+    /** Add-more overlay is playing its reverse (close) slide before it unmounts.
+     *  Kept mounted while `sourceOverlayOpen || sourceOverlayClosing`. */
+    sourceOverlayClosing: boolean;
+    /** Provider whose read-only picker just rejected an OS drop (drives the toast). */
+    dropRejected: string | null;
+}
+interface TransientUiParams {
+    /** Read fresh each call — the motion gate's current snapshot. */
+    motion: () => MotionMode;
+    /** The REAL removal (orchestrator path). Called exactly once per id. */
+    reallyRemove: (fileId: string) => void;
+    /** Exit-animation duration. Keep in lockstep with --upup-fx-base. */
+    exitMs?: number;
+    /** Overlay reverse-slide duration. Keep in lockstep with --upup-fx-overlay. */
+    overlayMs?: number;
+    /** Drop-rejection toast lifetime. */
+    toastMs?: number;
+}
+interface TransientUiState extends ObservableController<TransientUiSnapshot> {
+    removeFileAnimated(fileId: string): void;
+    openSourceOverlay(): void;
+    closeSourceOverlay(): void;
+    flagDropRejected(provider: string): void;
+}
+/**
+ * The uploader's transient UI state: deferred file removal (marks a file
+ * `leaving` so the exit animation can play before the real removal fires),
+ * the add-more source overlay flag, and the drop-rejection toast flag. It is a
+ * plain observable so frameworks can drive it through `useSyncExternalStore`.
+ * All removals go through `reallyRemove` exactly once; when motion is `off`
+ * the deferral collapses to an immediate call so reduced-motion users never
+ * wait on an animation that will not run.
+ */
+declare function createTransientUiState({ motion, reallyRemove, exitMs, overlayMs, toastMs, }: TransientUiParams): TransientUiState;
+
+/** i18n option block (identical across frameworks). */
+interface UploaderI18nOptions {
+    bundle?: LocaleBundle;
+    locale?: LocaleBundle | string;
+    fallbackLocale?: LocaleBundle | string;
+    overrides?: PartialMessages;
+}
+/** Every callback the orchestrator/commands/proxy may invoke (framework-agnostic superset). */
+interface UploaderCallbacks extends OrchestratorCallbacks {
+    onFileAdded?: ((files: UploadFile[]) => void) | undefined;
+    onUploadProgress?: ((p: {
+        fileId: string;
+        loaded: number;
+        total: number;
+    }) => void) | undefined;
+    onStatusChange?: ((status: string) => void) | undefined;
+    onFileTypeMismatch?: ((file: File, acceptedTypes: string) => void) | undefined;
+    onRestrictionFailed?: ((file: File, reason: 'TYPE_MISMATCH' | 'FILE_TOO_LARGE' | 'FILE_TOO_SMALL' | 'LIMIT_EXCEEDED') => void) | undefined;
+    onDoneClicked?: (() => void) | undefined;
+    autoUpload?: boolean | undefined;
+}
+/** Options accepted by the factory (framework-agnostic superset; each framework's props satisfy this structurally). */
+interface UploaderControllerOptions extends Omit<CoreOptions, 'onError'>, UploaderCallbacks {
+    dark?: boolean | undefined;
+    theme?: UpupThemeConfig | undefined;
+    sources?: Array<FileSource | string> | undefined;
+    mini?: boolean | undefined;
+    animations?: boolean | undefined;
+    isProcessing?: boolean | undefined;
+    allowPreview?: boolean | undefined;
+    showBranding?: boolean | undefined;
+    quietCompletion?: boolean | undefined;
+    disableDragDrop?: boolean | undefined;
+    className?: string | undefined;
+    folderUpload?: {
+        allowDrop?: boolean;
+        showSelectFolderButton?: boolean;
+    } | undefined;
+    imageEditor?: boolean | ImageEditorOptions | undefined;
+    enablePaste?: boolean | undefined;
+    resumable?: ResumableUploadOptions | undefined;
+    i18n?: UploaderI18nOptions | undefined;
+    onIntegrationClick?: ((sourceId: string) => void) | undefined;
+    onPrepareFiles?: ((files: UploadFile[]) => Promise<UploadFile[]>) | undefined;
+    maxFiles?: number | undefined;
+}
+/** All resolved scalars + i18n + cloud-drive config (static, computed once). */
+interface UploaderResolved {
+    cloudDrives?: CloudDrivesConfig | undefined;
+    mini: boolean;
+    animations: boolean;
+    sources: FileSource[];
+    allowedFileTypes: string;
+    limit: number;
+    maxFileSize: MaxFileSizeObject;
+    multiple: boolean;
+    mode: 'client' | 'server';
+    serverUrl?: string | undefined;
+    folderUploadAllowDrop: boolean;
+    folderPickerButtonVisible: boolean;
+    imageEditor: ResolvedImageEditorOptions;
+    resumable?: ResumableUploadOptions | undefined;
+    translator: Translator;
+    translations: UiTranslations;
+    lang: string;
+    dir: 'ltr' | 'rtl';
+}
+/** Output of the pure normalizer: the CoreOptions object to build core with, plus all resolved values. */
+interface NormalizedUploaderOptions {
+    coreOptions: CoreOptions;
+    resolved: UploaderResolved;
+}
+/** Imperative command surface (delegates to core + orchestrator). */
+interface UploaderCommands {
+    handleSetSelectedFiles(newFiles: File[]): Promise<void>;
+    handleFileRemove(fileId: string): void;
+    handleRemoveAll(): void;
+    uploadFiles(newFiles: File[] | UploadFile[]): Promise<UploadFile[] | undefined>;
+    replaceFiles(newFiles: File[] | UploadFile[]): void;
+    startUpload(): Promise<UploadFile[] | undefined>;
+    retryUpload(fileId?: string): Promise<UploadFile[] | undefined>;
+    handleCancel(): void;
+    handlePause(): void;
+    handleResume(): void;
+    handleDone(): void;
+    resetState(): void;
+    openImageEditor(file: UploadFile): void;
+    closeImageEditor(): void;
+    saveImageEdit(editedImageData: string, mimeType?: string): void;
+    replaceFile(fileId: string, newFile: UploadFile): void;
+    setActiveSource(source: FileSource | undefined): void;
+    setIsAddingMore(value: boolean): void;
+    setViewMode(mode: 'grid' | 'list'): void;
+}
+/** Optional host injection points. */
+interface UploaderHostHooks {
+    /** Per-framework SSE wiring; called for each completed file in onFilesUploadComplete. Vanilla omits. */
+    connectSSE?: (file: UploadFile) => void;
+    /** Manual render-loop nudge (vanilla). Frameworks with reactive bridges omit. */
+    invalidate?: () => void;
+}
+/** Parameters for the factory: the host-created core, the raw options, and the precomputed normalization. */
+interface CreateUploaderControllerParams {
+    core: UpupCore;
+    options: UploaderControllerOptions;
+    normalized: NormalizedUploaderOptions;
+}
+/** Stable handle returned by the factory. */
+interface UploaderController {
+    core: UpupCore;
+    orchestrator: UploaderOrchestrator;
+    theme: ThemeStore;
+    /** Reduced-motion gate: `off` iff `animations={false}` or the OS asks. */
+    motionGate: MotionGate;
+    /** Deferred-removal / source-overlay / drop-rejection transient UI state. */
+    transientUi: TransientUiState;
+    resolved: UploaderResolved;
+    commands: UploaderCommands;
+    registerFileInput(el: HTMLInputElement | null): void;
+    getFileInput(): HTMLInputElement | null;
+    openFilePicker(): void;
+    /** Refresh the proxied callbacks (React calls every render; others once). */
+    updateCallbacks(callbacks: UploaderCallbacks): void;
+    /** Optional fan-in of core `state-change` + orchestrator + theme notifications. */
+    subscribe(listener: () => void): () => void;
+    /** Idempotent: orchestrator.init + theme.init + plugin registration + crash recovery + status-change. */
+    init(): void;
+    /** Idempotent + re-entrant: reverse of init; safe for Angular config rebuild. */
+    destroy(): void;
+}
+
+declare function normalizeUploaderOptions(options: UploaderControllerOptions): NormalizedUploaderOptions;
+
+declare function createUploaderController({ core, options, normalized }: CreateUploaderControllerParams, hostHooks?: UploaderHostHooks): UploaderController;
+
+interface ChildControllerLike {
+    init?(): void;
+    destroy?(): void;
+    subscribe?(listener: () => void): () => void;
+}
+interface CreateChildControllerOptions {
+    /** If provided and the controller supports subscribe(), wired on init() and unwired on destroy(). */
+    onChange?: () => void;
+}
+interface ChildControllerHandle<C extends ChildControllerLike> {
+    controller: C;
+    init(): void;
+    destroy(): void;
+}
+declare function createChildController<C extends ChildControllerLike>(factory: () => C, options?: CreateChildControllerOptions): ChildControllerHandle<C>;
+
+interface DriveBrowserState {
+    user?: DriveUser | undefined;
+    /** Contents of the currently displayed folder (legacy: googleFiles/oneDriveFiles/…). */
+    folder?: DriveFolder | undefined;
+    path: DriveFolder[];
+    selectedFiles: DriveFile[];
+    isClickLoading: boolean;
+    showLoader: boolean;
+    /** GIS: token client ready. Popup: set true after mount restore. */
+    isAuthReady: boolean;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    /** GIS only: user dismissed the consent popup. */
+    authCancelled: boolean;
+    /** GIS only: the acquired access token. */
+    token?: {
+        access_token: string;
+        expires_in: number;
+    } | undefined;
+    /** The one drive-failure surface (auth/load/download/search, any provider). undefined = no error. */
+    error?: DriveBrowserError | undefined;
+    /** Drives the "Load more" button. Wired in F-125 (hasMore/loadMore); defaults false until then. */
+    hasMore: boolean;
+    /** Load-more button spinner/disabled state. */
+    isLoadingMore: boolean;
+}
+interface DriveBrowserCallbacks {
+    /** Push downloaded files into the uploader (host maps to context setFiles). */
+    onFilesSelected: (files: File[]) => void;
+    /** Close the drive browser view (host maps to setActiveSource(undefined)). */
+    onClose: () => void;
+}
+/**
+ * Framework-agnostic cloud-drive browser store. One instance per provider per
+ * mounted drive view. Mirrors UploaderOrchestrator's subscribe/getSnapshot
+ * pattern so every framework binds it the same way.
+ */
+declare class DriveBrowserController {
+    private state;
+    private listeners;
+    private core;
+    private descriptor;
+    private callbacks;
+    private plugin;
+    private tokenClient;
+    private unsubs;
+    /** Real name of the folder being navigated into, captured at click time. */
+    private pendingFolder?;
+    /** Opaque continuation token from the most recent files-loaded/loadMoreFiles payload (F-125). */
+    private cursor?;
+    constructor(core: UpupCore, descriptor: DriveProviderDescriptor, callbacks: DriveBrowserCallbacks);
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => DriveBrowserState;
+    protected setState(partial: Partial<DriveBrowserState>): void;
+    private notify;
+    init(): void;
+    destroy(): void;
+    private restore;
+    private bindEvents;
+    /**
+     * The single session-teardown home (F-127). onSignedOut and onSessionExpired
+     * previously drifted independently — onSessionExpired forgot to clear
+     * selectedFiles/pendingFolder, leaking a stale selection into the next
+     * sign-in. Both now delegate here.
+     */
+    private resetSession;
+    private buildRootFolder;
+    private initGis;
+    signIn(): void;
+    retryAuth(): void;
+    private runPopupAuth;
+    signOut(): void;
+    /**
+     * Folder trail for the breadcrumb, owned here so every framework stays consistent
+     * (react/vue/svelte previously seeded it in a component effect that collapsed the
+     * trail; vanilla/angular had no seed at all). Root load resets to [root]; descending
+     * appends; re-loading a folder already in the trail truncates to it. Ids must stay
+     * unique — the breadcrumb is keyed by folder id.
+     */
+    private nextPath;
+    setPath(path: DriveFolder[]): void;
+    handleClick(file: DriveFile): void;
+    handleSubmit(): Promise<void>;
+    handleCancelDownload(): void;
+    onSelectCurrentFolder(): Promise<void>;
+    /**
+     * Append-driven pagination (F-125), mirroring onSelectCurrentFolder's
+     * await-then-use-the-return-value style rather than reacting to another
+     * files-loaded event — the same convention, not a second one. A no-op
+     * unless the plugin supports it, the current view has more to fetch, and
+     * a continuation token exists.
+     */
+    loadMore(): Promise<void>;
+    private downloadAndClose;
+}
+
+/** The subset of uploader options the dropzone reads. */
+interface DragDropOptions {
+    enablePaste?: boolean;
+    onFilesDragOver?: (files: File[]) => void;
+    onFilesDragLeave?: (files: File[]) => void;
+    onFilesDrop?: (files: File[]) => void;
+    onWarn?: (message: string) => void;
+}
+/** The subset of resolved props the dropzone reads. */
+interface DragDropProps {
+    disableDragDrop: boolean;
+    isProcessing: boolean;
+    folderUploadAllowDrop: boolean;
+}
+interface DragDropDeps {
+    core: UpupCore;
+    orchestrator: UploaderOrchestrator;
+    setFiles: (files: File[]) => void | Promise<void>;
+    /**
+     * Current selected-file count, read fresh on each recompute. Each host MUST
+     * supply the SAME source its file list renders from, so the dropzone border
+     * (`absoluteHasBorder`) stays in lockstep with the visible files:
+     *   - React / Vue / Svelte / Angular → `orchestrator.getSnapshot().files.size`
+     *     (their lists derive from the orchestrator snapshot, which is now a
+     *     projection of core.files refreshed on every `state-change` event)
+     *   - Vanilla                        → `core.files.size` (its list reads core)
+     * Both sources are now in sync after every file mutation: the orchestrator
+     * files map is rebuilt from `core.files` on each `state-change`, so
+     * `orchestrator.getSnapshot().files.size` always equals `core.files.size`
+     * after any mutation completes.
+     */
+    filesSize: () => number;
+    /** Getter so frameworks that re-read options each render (React) stay fresh. */
+    options: () => DragDropOptions;
+    /** Getter so frameworks that re-read props each render (React) stay fresh. */
+    props: () => DragDropProps;
+    /**
+     * Invoked when a file is dropped while a read-only drive picker is the
+     * active source (see `READONLY_DRIVE_SOURCES`). The host resolves the human
+     * provider label and raises the drop-rejection toast (core transient-UI
+     * store). When omitted, such a drop is silently ignored (the prior
+     * behavior). Core owns the DECISION (which source, that files were dropped);
+     * the host owns the i18n label + toast.
+     */
+    onReadonlyDropRejected?: (source: FileSource) => void;
+}
+interface DragDropSnapshot {
+    isDragging: boolean;
+    absoluteIsDragging: boolean;
+    absoluteHasBorder: boolean;
+}
+declare class DragDropController implements ObservableController<DragDropSnapshot> {
+    private deps;
+    private isDragging;
+    private snapshot;
+    private listeners;
+    private unsubOrchestrator;
+    constructor(deps: DragDropDeps);
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => DragDropSnapshot;
+    /** Subscribe to the orchestrator so border/dragging derive on change. Call on mount. Idempotent. */
+    init(): void;
+    private get disabled();
+    private compute;
+    /**
+     * Recompute the cached snapshot from current inputs and notify if it changed.
+     * Runs automatically on drag events and orchestrator changes. Hosts may also call
+     * it to refresh after external state the controller cannot observe via the
+     * orchestrator — e.g. a framework that removes files through `core.removeFile`
+     * directly (which emits no orchestrator notify), leaving the file-count-derived
+     * `absoluteHasBorder` stale.
+     */
+    recompute(): void;
+    private notify;
+    handleDragOver(e: DragEvent): void;
+    handleDragLeave(e: DragEvent): void;
+    /** True when the drag payload carries at least one file. */
+    private dropHasFiles;
+    handleDrop(e: DragEvent): Promise<void>;
+    handlePaste(e: ClipboardEvent): void;
+    destroy(): void;
+}
+
+interface DriveEventCallbacks {
+    onAuthenticated: (payload: unknown) => void;
+    onSignedOut: () => void;
+    onSessionExpired: () => void;
+    onFilesLoaded: (payload: unknown) => void;
+    onStateChange: (payload: unknown) => void;
+    onError: (payload?: unknown) => void;
+}
+declare function bindDriveEvents(core: UpupCore, provider: string, callbacks: DriveEventCallbacks): () => void;
+
+type DroppedFilesResult = {
+    files: File[];
+    skippedDirectory: boolean;
+};
+declare function collectDroppedFiles(dataTransfer: Pick<DataTransfer, 'items' | 'files'>, allowFolderDrop: boolean): Promise<DroppedFilesResult>;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare function b64EncodeUnicode(str: string): string;
+
+declare const fileAppendParams: (file: File) => UploadFile;
+declare const revokeFileUrl: (file: UploadFile) => void;
+
+type ImageOutputOptions = {
+    mimeType?: string;
+    quality?: number;
+    fileName?: (original: File) => string;
+};
+/**
+ * Convert a data-URL (base64 or plain) string to a Blob.
+ * Works with any MIME type encoded as `data:<mime>;base64,<data>`.
+ */
+declare function dataURLtoBlob(dataURL: string): Blob;
+/**
+ * Create a new UploadFile from a Blob, preserving the identity (`id`)
+ * of the original file. A fresh blob URL is created for the new file.
+ *
+ * @param blob      The edited image blob.
+ * @param original  The original UploadFile being replaced.
+ * @param output    Optional output settings (mimeType, quality, fileName).
+ * @returns A new UploadFile with the same `id` but updated content.
+ */
+declare function blobToUploadFile(blob: Blob, original: UploadFile, output?: ImageOutputOptions): UploadFile;
+/**
+ * Replace a file in a Map<string, UploadFile>, revoking the old blob URL
+ * to prevent memory leaks.
+ *
+ * @param map     The current files map (not mutated — a new Map is returned).
+ * @param fileId  The id of the file to replace.
+ * @param newFile The replacement UploadFile.
+ * @returns A new Map with the replaced entry.
+ */
+declare function revokeAndReplace(map: Map<string, UploadFile>, fileId: string, newFile: UploadFile): Map<string, UploadFile>;
+
+/**
+ * Loads the Google Identity Services (GIS) API script.
+ * Cached — only loads once per page lifecycle.
+ */
+declare function loadGoogleIdentityServices(): Promise<void>;
+
+/** Maps each FileSource to its i18n translation key. No React dependency. */
+declare const sourceNameKeys: Record<FileSource, keyof Translations>;
+
+declare function isUploadActive(status: UploadStatus): boolean;
+declare function isUploadIdle(status: UploadStatus): boolean;
+/** Whether a file's remove control is locked. "Has progress" used to imply
+ *  "in flight", but a crash-restored PAUSED file now carries its resumable
+ *  byte offset as progress too — and a paused file must stay discardable,
+ *  because discarding is the one path that aborts its server-side upload and
+ *  drops its persisted session. */
+declare function isFileRemovalLocked(progress: number | null | undefined, fileStatus: UploadStatus): boolean;
+
+/**
+ * What a paused/reloaded multipart upload needs to find its way back to the
+ * server-side upload it left behind. Deliberately NOT stored: the uploadId —
+ * the HMAC-signed `token` is its only carrier (server-side S2), so a session
+ * leaked out of localStorage still cannot forge a continuation request.
+ */
+interface MultipartSession {
+    /** The server-issued upload token: the sole carrier of key + uploadId +
+     *  owner + size envelope. Replaced by a fresh one on every resume. */
+    token: string;
+    /** Object key the upload targets — diagnostics only; the token is what the
+     *  server actually binds against. */
+    key: string;
+    /** Bytes per part for every part except the last one. Resume validates the
+     *  server-reported part sizes against it before trusting the session. */
+    partSize: number;
+    /** Epoch ms of the last write — drives the 24h TTL below. */
+    updatedAt: number;
+    /** Bytes uploaded so far (used for progress pre-population on resume) */
+    uploadedBytes?: number;
+    /** The serverUrl this session belongs to. A session saved against server A
+     *  must never be resumed against server B. */
+    scope?: string;
+    /** `file.metadata.originalContentHash`, when the checksum pipeline step
+     *  ran. Opportunistic: compared on resume only when both sides have it. */
+    contentHash?: string;
+}
+/**
+ * Generate a deterministic fingerprint for a file to identify resumable sessions.
+ */
+declare function fileFingerprint(file: File): string;
+/**
+ * Save a multipart session to localStorage.
+ */
+declare function saveSession(fingerprint: string, session: MultipartSession): void;
+/**
+ * Load a multipart session from localStorage, if it exists and is not expired.
+ */
+declare function loadSession(fingerprint: string): MultipartSession | null;
+/**
+ * Update only the progress-related fields of an existing session.
+ */
+declare function updateSessionProgress(fingerprint: string, uploadedBytes: number): void;
+/**
+ * Remove a multipart session (on complete or abort).
+ */
+declare function removeSession(fingerprint: string): void;
+/**
+ * Clear all multipart sessions (e.g., on user cancel).
+ */
+declare function clearAllSessions(): void;
+
+declare const MIME_EXTENSION_MAP: Record<string, string>;
+declare function sanitizeFileName(value: string): string;
+declare function extensionFromMime(type: string): string;
+declare function fileNameFromContentDisposition(header: string | null): string | undefined;
+declare function deriveFetchedFileName(url: string, response: Response, blob: Blob): string;
+
+export { BrowserRuntime, type ChildControllerHandle, type ChildControllerLike, type CreateChildControllerOptions, type CreateUploaderControllerParams, CredentialStrategy, DEFAULT_MAX_FILE_SIZE, DEFAULT_SOURCES, DragDropController, type DragDropDeps, type DragDropOptions, type DragDropProps, type DragDropSnapshot, type DriveBrowserCallbacks, DriveBrowserController, type DriveBrowserState, type DriveEventCallbacks, DriveProviderDescriptor, type DroppedFilesResult, MIME_EXTENSION_MAP, type MotionGate, type MotionGateParams, type MotionMode, type MultipartSession, type NormalizedUploaderOptions, OrchestratorCallbacks, RuntimeAdapter, SSEProcessor, ThemeStore, type TransientUiParams, type TransientUiSnapshot, type TransientUiState, UploadManager, UploadResult, UploadStrategy, type UploaderCallbacks, type UploaderCommands, type UploaderController, type UploaderControllerOptions, type UploaderHostHooks, type UploaderI18nOptions, UploaderOrchestrator, type UploaderResolved, b64EncodeUnicode, bindDriveEvents, blobToUploadFile, clearAllSessions, cn, collectDroppedFiles, createChildController, createMotionGate, createTransientUiState, createUploaderController, dataURLtoBlob, deriveFetchedFileName, extensionFromMime, fileAppendParams, fileFingerprint, fileNameFromContentDisposition, getDir, isFileRemovalLocked, isUploadActive, isUploadIdle, loadGoogleIdentityServices, loadSession, normalizeSource, normalizeUploaderOptions, removeSession, revokeAndReplace, revokeFileUrl, sanitizeFileName, saveSession, sourceNameKeys, updateSessionProgress };