/**
 * BlockType defines the different types of blocks in the Owner Free Filesystem (OFF).
 * In OFF, blocks are organized in a hierarchy where each type serves a specific purpose:
 *
 * Data Storage:
 * - RawData: Basic data storage without additional features
 * - OwnedDataBlock: Data blocks with ownership information
 * - EncryptedOwnedDataBlock: Encrypted data blocks with ownership
 *
 * Privacy & Security:
 * - OwnerFreeWhitenedBlock: Data XORed with random blocks for privacy
 * - Random: Random data blocks used for whitening
 * - FECData: Forward Error Correction data for recovery
 *
 * Organization & Management:
 * - ConstituentBlockList (CBL): Lists of block references and metadata
 * - Handle: References to blocks stored elsewhere
 */
export declare enum BlockType {
    /**
     * Used for uninitialized or invalid blocks
     */
    Unknown = -1,
    /**
     * A block that has been XORed with random data for privacy.
     * Key features:
     * 1. Data is obscured through XOR operations
     * 2. Original data can be recovered with the random blocks
     * 3. Provides privacy without encryption overhead
     */
    OwnerFreeWhitenedBlock = 0,
    /**
     * A block containing random data.
     * Used for:
     * 1. Whitening other blocks through XOR
     * 2. Adding entropy to the system
     * 3. Supporting privacy features
     */
    Random = 1,
    /**
     * A basic block containing raw data.
     * Features:
     * 1. Simple data storage
     * 2. No additional metadata
     * 3. Maximum storage efficiency
     */
    RawData = 2,
    /**
     * A block containing Forward Error Correction data.
     * Used for:
     * 1. Data recovery
     * 2. Error detection
     * 3. System reliability
     */
    FECData = 3,
    /**
     * A block containing data with ownership information.
     * Features:
     * 1. Owner identification
     * 2. Access control
     * 3. Metadata support
     */
    EphemeralOwnedDataBlock = 10,
    /**
     * A block containing references to other blocks.
     * Used for:
     * 1. Organizing related blocks
     * 2. Storing metadata
     * 3. Building hierarchies
     */
    ConstituentBlockList = 20,
    /**
     * An extended CBL with file metadata.
     * Features:
     * 1. File name preservation
     * 2. MIME type tracking
     * 3. File system integration
     */
    ExtendedConstituentBlockListBlock = 21,
    /**
     * A Vault CBL with vault header and entry property records.
     * Features:
     * 1. Vault metadata (name, owner, shared members)
     * 2. Entry property records for listing/searching
     * 3. Index-aligned with block ID array
     */
    VaultConstituentBlockList = 22,
    /**
     * A Tarball CBL that bundles multiple file/data entries into a single CBL archive.
     * Features:
     * 1. Manifest with entry descriptors (file name, MIME type, data length, CBL address)
     * 2. Optional whole-archive bzip2 compression
     * 3. Optional whole-archive ECIES encryption
     */
    TarballConstituentBlockList = 23,
    /**
     * An encrypted block with ownership information.
     * Features:
     * 1. Data encryption
     * 2. Owner identification
     * 3. Access control
     */
    EncryptedOwnedDataBlock = 30,
    /**
     * An encrypted block containing block references.
     */
    EncryptedConstituentBlockListBlock = 31,
    /**
     * An encrypted block containing block references and metadata.
     */
    EncryptedExtendedConstituentBlockListBlock = 32,
    /**
     * A block that has been encrypted multiple times.
     */
    MultiEncryptedBlock = 33,
    /**
     * An encrypted Vault CBL.
     */
    EncryptedVaultConstituentBlockListBlock = 34,
    /**
     * An encrypted Tarball CBL archive.
     */
    EncryptedTarballConstituentBlockListBlock = 35,
    /**
     * A reference to a block stored elsewhere.
     * Features:
     * 1. Lazy loading
     * 2. Memory efficiency
     * 3. Remote storage support
     */
    Handle = 40
}
/**
 * Block types that are ephemeral and do not have a persistent ID.
 */
export declare const EphemeralBlockTypes: readonly BlockType[];
/**
 * Block types that are encrypted
 */
export declare const EncryptedBlockTypes: readonly BlockType[];
export default BlockType;
//# sourceMappingURL=blockType.d.ts.map