/**
 * VirtualFolderStorage
 *
 * A storage implementation that creates a virtual folder structure from multiple
 * real folders. This is used to expose the dedicated server's content (behavior_packs,
 * resource_packs, world) as a unified storage.
 *
 * The virtual storage maps named paths to real folders:
 * - /behavior_packs/ -> development_behavior_packs folder
 * - /resource_packs/ -> development_resource_packs folder
 * - /world/ -> worlds/defaultWorld folder
 */
import IFolder from "./IFolder";
import IFile from "./IFile";
import IStorage from "./IStorage";
import StorageBase from "./StorageBase";
import FolderBase from "./FolderBase";
export interface IVirtualFolderMapping {
    /** The virtual path name (e.g., "behavior_packs") */
    virtualName: string;
    /** The real folder to map to this virtual path */
    realFolder: IFolder;
}
/**
 * A virtual folder that delegates to real folders based on a mapping.
 * This creates a unified view of multiple storage locations.
 */
export default class VirtualFolderStorage extends StorageBase implements IStorage {
    rootFolder: VirtualRootFolder;
    private _mappings;
    constructor(mappings?: IVirtualFolderMapping[]);
    /**
     * Add a folder mapping to the virtual storage.
     * @param mapping The mapping to add
     */
    addMapping(mapping: IVirtualFolderMapping): void;
    /**
     * Remove a folder mapping from the virtual storage.
     * @param virtualName The virtual name to remove
     */
    removeMapping(virtualName: string): void;
    /**
     * Get all current mappings.
     */
    getMappings(): IVirtualFolderMapping[];
    getAvailable(): Promise<boolean>;
    getUsesPollingBasedUpdating(): boolean;
    incrementalScanForChanges(): Promise<void>;
}
/**
 * The root folder of a VirtualFolderStorage.
 * Maps virtual folder names to real folder implementations.
 */
declare class VirtualRootFolder extends FolderBase implements IFolder {
    private _storage;
    private _virtualFolders;
    private _name;
    folders: {
        [name: string]: IFolder | undefined;
    };
    files: {
        [name: string]: IFile | undefined;
    };
    get name(): string;
    get parentFolder(): IFolder | null;
    get storage(): IStorage;
    get fullPath(): string;
    get extendedPath(): string;
    constructor(storage: VirtualFolderStorage);
    addVirtualSubfolder(name: string, realFolder: IFolder): void;
    removeVirtualSubfolder(name: string): void;
    ensureFolder(name: string): IFolder;
    ensureFile(_name: string): IFile;
    exists(): Promise<boolean>;
    ensureExists(): Promise<boolean>;
    load(_force?: boolean): Promise<Date>;
    saveAll(_force?: boolean): Promise<boolean>;
    moveTo(_newStorageRelativePath: string): Promise<boolean>;
    rename(_newName: string): Promise<boolean>;
    deleteThisFolder(): Promise<boolean>;
    deleteFile(_name: string): Promise<boolean>;
    deleteFileFromRelativePath(_path: string): Promise<boolean>;
    createFile(_name: string): Promise<IFile>;
    deleteAllFolderContents(): Promise<boolean>;
    removeFolder(_name: string): boolean;
    getFolderFromRelativePathLocal(relativePath: string): IFolder | undefined;
    getFolderByIndex(index: number): IFolder | undefined;
    getSortedFolderKeys(): string[];
    getSortedFileKeys(): string[];
    ensureFolderFromRelativePath(relativePath: string): Promise<IFolder>;
    ensureFileFromRelativePath(_relativePath: string): Promise<IFile>;
    setStructureFromFileList(_fileList: string[]): Promise<void>;
    clearAllManagers(): void;
    getFolderRelativePath(_toFolder: IFolder): string | undefined;
    folderExists(name: string): boolean;
    fileExists(_name: string): boolean;
    getFileFromRelativePath(relativePath: string): Promise<IFile | undefined>;
    getFolderFromRelativePath(relativePath: string): Promise<IFolder | undefined>;
    scanForChanges(): Promise<void>;
}
export {};