import { VSBuffer, VSBufferReadable, VSBufferReadableStream } from '../../../base/common/buffer';
import { CancellationToken } from '../../../base/common/cancellation';
import { Disposable, IDisposable } from '../../../base/common/lifecycle';
import { CoordinationArgs } from '../../../base/common/resources';
import { URI } from '../../../base/common/uri';
import { FileChangesEvent, FileDeleteOptions, FileOperationEvent, FileSystemProviderCapabilities, ICreateFileOptions, IFileContent, IFileService, IFileStat, IFileStatWithMetadata, IFileStreamContent, IFileSystemProvider, IFileSystemProviderActivationEvent, IFileSystemProviderCapabilitiesChangeEvent, IFileSystemProviderRegistrationEvent, IRawFileChangesEvent, IReadFileOptions, IReadFileStreamOptions, IResolveFileOptions, IResolveFileResult, IResolveFileResultWithMetadata, IResolveMetadataFileOptions, IWatchOptions, IWriteFileOptions } from '../../../platform/files/common/files';
import { ILogService } from '../../../platform/log/common/log';
export declare class FileService extends Disposable implements IFileService {
    private readonly logService;
    readonly _serviceBrand: undefined;
    private readonly BUFFER_SIZE;
    constructor(logService: ILogService);
    private readonly _onDidChangeFileSystemProviderRegistrations;
    readonly onDidChangeFileSystemProviderRegistrations: import("../../../base/common/event").Event<IFileSystemProviderRegistrationEvent>;
    private readonly _onWillActivateFileSystemProvider;
    readonly onWillActivateFileSystemProvider: import("../../../base/common/event").Event<IFileSystemProviderActivationEvent>;
    private readonly _onDidChangeFileSystemProviderCapabilities;
    readonly onDidChangeFileSystemProviderCapabilities: import("../../../base/common/event").Event<IFileSystemProviderCapabilitiesChangeEvent>;
    private readonly provider;
    registerProvider(scheme: string, provider: IFileSystemProvider): IDisposable;
    getProvider(scheme: string): IFileSystemProvider | undefined;
    activateProvider(scheme: string): Promise<void>;
    canHandleResource(resource: URI): Promise<boolean>;
    hasProvider(resource: URI): boolean;
    hasCapability(resource: URI, capability: FileSystemProviderCapabilities): boolean;
    listCapabilities(): Iterable<{
        scheme: string;
        capabilities: FileSystemProviderCapabilities;
    }>;
    protected withProvider(resource: URI): Promise<IFileSystemProvider>;
    private withReadProvider;
    private withWriteProvider;
    private readonly _onDidRunOperation;
    readonly onDidRunOperation: import("../../../base/common/event").Event<FileOperationEvent>;
    resolve(resource: URI, options: IResolveMetadataFileOptions): Promise<IFileStatWithMetadata>;
    resolve(resource: URI, options?: IResolveFileOptions): Promise<IFileStat>;
    private doResolveFile;
    private toFileStat;
    resolveAll(toResolve: {
        resource: URI;
        options?: IResolveFileOptions;
    }[]): Promise<IResolveFileResult[]>;
    resolveAll(toResolve: {
        resource: URI;
        options: IResolveMetadataFileOptions;
    }[]): Promise<IResolveFileResultWithMetadata[]>;
    exists(resource: URI): Promise<boolean>;
    canCreateFile(resource: URI, options?: ICreateFileOptions): Promise<Error | true>;
    private doValidateCreateFile;
    createFile(resource: URI, bufferOrReadableOrStream?: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: ICreateFileOptions): Promise<IFileStatWithMetadata>;
    writeFile(resource: URI, bufferOrReadableOrStream: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: IWriteFileOptions): Promise<IFileStatWithMetadata>;
    private validateWriteFile;
    readFile(resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent>;
    private doReadFileAtomic;
    private doReadFile;
    readFileStream(resource: URI, options?: IReadFileStreamOptions, token?: CancellationToken): Promise<IFileStreamContent>;
    private doReadFileStream;
    private readFileStreamed;
    private readFileBuffered;
    private readFileUnbuffered;
    private validateReadFile;
    private validateReadFileLimits;
    canMove(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
    canCopy(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
    private doCanMoveCopy;
    move(source: URI, target: URI, overwrite?: boolean, coordinationArgs?: CoordinationArgs): Promise<IFileStatWithMetadata>;
    copy(source: URI, target: URI, overwrite?: boolean, coordinationArgs?: CoordinationArgs): Promise<IFileStatWithMetadata>;
    private doMoveCopy;
    private doCopyFile;
    private doCopyFolder;
    private doValidateMoveCopy;
    private getExtUri;
    private isPathCaseSensitive;
    createFolder(resource: URI): Promise<IFileStatWithMetadata>;
    private mkdirp;
    canDelete(resource: URI, options?: Partial<FileDeleteOptions>): Promise<Error | true>;
    private doValidateDelete;
    del(resource: URI, options?: Partial<FileDeleteOptions>): Promise<void>;
    /**
     * Providers can send unlimited amount of `IFileChange` events
     * and we want to protect against this to reduce CPU pressure.
     * The following settings limit the amount of file changes we
     * process at once.
     * (https://github.com/microsoft/vscode/issues/124723)
     */
    private static readonly FILE_EVENTS_THROTTLING;
    private readonly _onDidFilesChange;
    readonly onDidFilesChange: import("../../../base/common/event").Event<FileChangesEvent>;
    private readonly _onDidWatchError;
    readonly onDidWatchError: import("../../../base/common/event").Event<Error>;
    private readonly _onDidChangeFilesRaw;
    readonly onDidChangeFilesRaw: import("../../../base/common/event").Event<IRawFileChangesEvent>;
    private readonly activeWatchers;
    private readonly caseSensitiveFileEventsWorker;
    private readonly caseInsensitiveFileEventsWorker;
    private readonly nonRecursiveWatchedResources;
    private onDidChangeFile;
    watch(resource: URI, options?: IWatchOptions): IDisposable;
    private doWatch;
    private toWatchKey;
    dispose(): void;
    private readonly writeQueue;
    private doWriteBuffered;
    private doWriteStreamBufferedQueued;
    private doWriteReadableBufferedQueued;
    private doWriteBuffer;
    private doWriteUnbuffered;
    private doWriteUnbufferedQueued;
    private doPipeBuffered;
    private doPipeBufferedQueued;
    private doPipeUnbuffered;
    private doPipeUnbufferedQueued;
    private doPipeUnbufferedToBuffered;
    private doPipeUnbufferedToBufferedQueued;
    private doPipeBufferedToUnbuffered;
    protected throwIfFileSystemIsReadonly<T extends IFileSystemProvider>(provider: T, resource: URI): T;
    private throwIfFileIsReadonly;
    private resourceForError;
}
//# sourceMappingURL=fileService.d.ts.map