/// <reference types="node" />
import { Volume } from 'memfs';
import { Node, Link } from 'memfs/lib/node';
declare class SharedVolume extends Volume {
    dev: BlockDevice;
    root: LinkSharedVolume;
    inodes: {
        [ino: number]: NodeSharedVolume;
    };
    debug: (...a: any[]) => void;
    constructor(props?: SharedVolumeProps);
    static from(props: SharedVolumeProps): SharedVolume;
    to(): SharedVolumeProps;
    writeBlob(path: string, buf: Uint8Array): void;
    createLink(parent?: LinkSharedVolume, name?: string, isDirectory?: boolean, perm?: number): Link;
    deleteLink(link: LinkSharedVolume): boolean;
    createNode(isDirectory?: boolean, perm?: number): NodeSharedVolume;
    getNodeShared(ino: number): NodeSharedVolume;
    createSymlink(target: string, filename: string): Link;
    /**
     * Overriding this from memfs Volume to support relative symlinks.
     */
    getResolvedLink(filenameOrSteps: string | string[]): Link | null;
    _fetchNode(ino: number): NodeSharedVolume;
}
declare type SharedVolumeProps = {
    dev?: BlockDeviceProps;
};
declare class BlockDevice {
    blockSize: number;
    blockCount: number;
    raw: ArrayBuffer;
    bitset: Uint8Array;
    cursors: Uint32Array;
    constructor(props?: BlockDeviceProps);
    static from(props: BlockDeviceProps): BlockDevice;
    to(): BlockDeviceProps;
    get(blockNo: number): Uint8Array;
    isFree(blockNo: number): boolean;
    get blockCursor(): number;
    set blockCursor(i: number);
    get boundaryCursor(): number;
    set boundaryCursor(i: number);
    get blobCursor(): number;
    set blobCursor(i: number);
    alloc(): number;
    allocBlob(size: number): Buffer;
    getBlob(offset: number, size: number): Buffer;
    readText(blockNo: number, offset?: number): {
        buf: string;
        size: number;
    };
    read(blockNo: number, offset?: number, size?: number): {
        buf: Uint8Array;
        size: number;
    };
    readInto(blockNo: number, offset: number, size: number, buf: Uint8Array, at: number): number;
    writeText(blockNo: number, value: string, offset?: number): number;
    write(blockNo: number, value: Uint8Array, offset?: number): number;
}
declare type BlockDeviceProps = {
    blockSize?: number;
    size?: number;
    raw?: ArrayBuffer;
    bitset?: Uint8Array;
    cursors?: Uint32Array;
};
declare class NodeSharedVolume extends Node {
    vol: SharedVolume;
    ver: number;
    isBlob: boolean;
    _link?: LinkSharedVolume;
    constructor(vol: SharedVolume, ino: number, perm?: number);
    setModeProperty(property: number): void;
    getLink(parent?: LinkSharedVolume, name?: string): LinkSharedVolume;
    setBlob(blob: Buffer): void;
    touch(): void;
    del(): void;
    push(): void;
    pull(): void;
    _read(): {
        header: InodeData;
        rdc?: number;
    };
    _write(header: InodeData, buf?: Uint8Array): number;
    _writeJson(obj: {}): number;
    _writeTrail(buf: Uint8Array, offset: number): void;
    _readTrail(buf: Uint8Array, offset: number): void;
    _next(header?: InodeData): NodeSharedVolume;
}
declare class LinkSharedVolume extends Link {
    vol: SharedVolume;
    parent: LinkSharedVolume;
    node: NodeSharedVolume;
    ver: number;
    _dirty: boolean;
    constructor(vol: SharedVolume, parent: Link, name: string);
    createChild(name: string, node?: NodeSharedVolume): LinkSharedVolume;
    setChild(name: string, link?: Link): Link;
    deleteChild(link: Link): void;
    touch(): void;
    setNode(node: NodeSharedVolume): void;
    getNode(): NodeSharedVolume;
    push(): void;
    pull(): void;
}
declare type InodeData = {
    p: number;
    m: number;
    z?: number;
    n?: number;
    v?: number;
    symlink?: string[];
    blob?: [number];
};
export { SharedVolume, SharedVolumeProps, BlockDevice, BlockDeviceProps };