import type { TeamSendTask } from '../team-send-contract.js';
import { type ArkmeFileOpenResult, type ArkmeFilePolicy, type ArkmeFileProgress, type ArkmeFileReception, type ArkmeFileSendInput, type ArkmeFileSendTask, type ArkmeLocalFile } from '../file-transfer-contract.js';
import type { ArkmeUploadedAsset, ArkmeSourceSendResult } from '../types.js';
type Metadata = Pick<ArkmeLocalFile, 'fileName' | 'mimeType' | 'size'>;
interface StoredFile extends ArkmeLocalFile {
    sha256: string;
    createdAtMillis: number;
    asset?: ArkmeUploadedAsset;
    retention?: 'references';
    longArticle?: true;
}
export type FileTransferSendOutcome = {
    kind: 'owner_accepted';
    result: ArkmeSourceSendResult;
} | {
    kind: 'owner_not_accepted';
    message: string;
    code?: string;
    retryable?: boolean;
} | {
    kind: 'owner_outcome_unknown';
    message?: string;
    code?: string;
};
export interface FileTransferPorts {
    currentUser(): Promise<number>;
    retainedFileRefs?(userId: number): Promise<readonly string[]>;
    validateSource(sourceRef: string): Promise<void>;
    upload(path: string, metadata: StoredFile, progress: (value: ArkmeFileProgress) => void, userId: number, signal: AbortSignal): Promise<ArkmeUploadedAsset>;
    send(input: ArkmeFileSendInput, assets: ArkmeUploadedAsset[], backgroundSound: import('../types.js').ArkmeRichBackgroundSoundInput | undefined, userId: number, signal: AbortSignal): Promise<FileTransferSendOutcome>;
    fetchMedia(ref: string, signal: AbortSignal): Promise<{
        response: Response;
        descriptor: Metadata;
    }>;
    openPath?(path: string, signal: AbortSignal): Promise<void>;
    reconcile?(input: ArkmeFileSendInput, signal: AbortSignal): Promise<ArkmeSourceSendResult | undefined>;
}
/** Plugin-owned files, not DSH session attachments. No client-controlled path is persisted. */
export declare class FileTransfers {
    private readonly directory;
    private readonly ports;
    private readonly states;
    private writes;
    private mutations;
    private directUploads;
    private readonly uploadingRefs;
    private queue;
    private readonly jobs;
    private readonly controllers;
    private readonly receptions;
    private readonly policy;
    constructor(directory: string, ports: FileTransferPorts, maxBytes: number);
    capabilities(): ArkmeFilePolicy;
    cancelActive(): void;
    settled(): Promise<void>;
    private root;
    private path;
    private openDirectory;
    private nativeOpenPath;
    private assertUser;
    private state;
    private save;
    private exclusive;
    private validateMetadata;
    stageLongArticleImage(temporaryPath: string, metadata: Metadata, expectedUserId?: number): Promise<ArkmeLocalFile>;
    stage(temporaryPath: string, metadata: Metadata, expectedUserId?: number, retention?: 'references'): Promise<ArkmeLocalFile>;
    private stageLocal;
    private prune;
    /** Validate new references and persist their owner without a cleanup/removal gap. Local I/O only. */
    withReferences<T>(refs: readonly string[], userId: number, persist: () => Promise<T>): Promise<T>;
    readLocal(ref: string): Promise<{
        path: string;
        file: ArkmeLocalFile;
    }>;
    openLocal(ref: string, signal?: AbortSignal): Promise<ArkmeFileOpenResult>;
    openLocalFolder(ref: string, signal?: AbortSignal): Promise<{
        folderOpened: true;
    }>;
    private openLocalTarget;
    files(): Promise<ArkmeLocalFile[]>;
    remove(ref: string): Promise<void>;
    tasks(sourceRef?: string): Promise<ArkmeFileSendTask[]>;
    /** Internal Team delivery uses the existing account store and file-reference lock. */
    teamSends(userId: number): Promise<TeamSendTask[]>;
    mutateTeamSends(userId: number, mutate: (tasks: TeamSendTask[]) => void): Promise<TeamSendTask[]>;
    stageBytes(contentBase64: string, metadata: Omit<Metadata, 'size'>): Promise<ArkmeLocalFile>;
    discard(taskRef: string): Promise<void>;
    reconcile(taskRef: string): Promise<ArkmeFileSendTask>;
    enqueue(input: ArkmeFileSendInput): Promise<ArkmeFileSendTask>;
    private imageFailure;
    uploadLongArticleImages(fileRefs: readonly string[], signal?: AbortSignal): Promise<ArkmeUploadedAsset[]>;
    uploadRefs(fileRefs: readonly string[], signal?: AbortSignal, progress?: (ref: string, value: ArkmeFileProgress) => void): Promise<ArkmeUploadedAsset[]>;
    private uploadDirectRefs;
    retry(taskRef: string): Promise<ArkmeFileSendTask>;
    private schedule;
    reception(mediaRef: string, start?: boolean): Promise<ArkmeFileReception>;
}
export {};
//# sourceMappingURL=file-transfers.d.ts.map