type ValidityStartHeight = {
    relativeValidityStartHeight: number;
} | {
    absoluteValidityStartHeight: number;
};
declare enum HashAlgorithm {
    Blake2b = 1,
    Sha256 = 3,
    Sha512 = 4
}
declare enum AccountType {
    Basic = "basic",
    Vesting = "vesting",
    HTLC = "htlc",
    Staking = "staking"
}
declare enum InherentType {
    Reward = "reward",
    Jail = "jail",
    Penalize = "penalize"
}
/**
 * Represents constants used in the policy module of the blockchain.
 */
interface PolicyConstants {
    /**
     * The staking contract address in the blockchain.
     */
    stakingContractAddress: string;
    /**
     * The address that receives the block rewards (coinbase).
     */
    coinbaseAddress: string;
    /**
     * The maximum validity window for transactions (number of blocks).
     */
    transactionValidityWindow: number;
    /**
     * The maximum size (in bytes) of the body of a micro block.
     */
    maxSizeMicroBody: number;
    /**
     * The version number of the policy constants.
     */
    version: number;
    /**
     * The total number of validator slots in the network.
     */
    slots: number;
    /**
     * The number of blocks in a batch.
     */
    blocksPerBatch: number;
    /**
     * The number of batches in an epoch.
     */
    batchesPerEpoch: number;
    /**
     * The total number of blocks in an epoch.
     */
    blocksPerEpoch: number;
    /**
     * The deposit amount required for a validator slot (in smallest currency unit, e.g., Lunas).
     */
    validatorDeposit: number;
    /**
     * The minimum stake required to participate in staking (in smallest currency unit, e.g., Lunas).
     */
    minimumStake: number;
    /**
     * The total supply of coins in the network (in smallest currency unit, e.g., Lunas).
     */
    totalSupply: number;
    /**
     * The number of epochs for which a validator is jailed after misbehavior.
     */
    jailEpochs: number;
    /**
     * The block number of the genesis block.
     */
    genesisBlockNumber: number;
    /**
     * The time (in seconds) between the production of two consecutive blocks.
     */
    blockSeparationTime: number;
}
interface BasicAccount {
    type: AccountType.Basic;
    address: string;
    balance: number;
}
interface VestingAccount {
    type: AccountType.Vesting;
    address: string;
    balance: number;
    owner: string;
    vestingStart: number;
    vestingStepBlocks: number;
    vestingStepAmount: number;
    vestingTotalAmount: number;
}
interface HtlcAccount {
    type: AccountType.HTLC;
    address: string;
    balance: number;
    sender: string;
    recipient: string;
    hashRoot: string;
    hashCount: number;
    timeout: number;
    totalAmount: number;
}
interface StakingAccount {
    type: AccountType.Staking;
    address: string;
    balance: number;
}
type Account = BasicAccount | VestingAccount | HtlcAccount | StakingAccount;
interface Transaction {
    hash: string;
    blockNumber?: number;
    timestamp?: bigint;
    confirmations?: number;
    size: number;
    relatedAddresses: Set<string>;
    from: string;
    fromType: number;
    to: string;
    toType: number;
    value: number;
    fee: number;
    senderData: string;
    recipientData: string;
    flags: number;
    validityStartHeight: number;
    proof: string;
    networkId: number;
}
interface Staker {
    address: string;
    balance: number;
    delegation?: string;
    inactiveBalance: number;
    inactiveFrom: number | null;
    retiredBalance: number;
}
interface Validator {
    address: string;
    signingKey: string;
    votingKey: string;
    rewardAddress: string;
    signalData?: string;
    balance: number;
    /**
     * The total amount of stakers in the valiator
     */
    numStakers: number;
    /**
     * Wether the validator has been retired
     */
    retired: boolean;
    /**
     * The block in which the validator was inactive from
     */
    inactivityFlag?: number;
    /**
     * The block in which the validator was jailed from
     */
    jailedFrom?: number;
}
interface Slot {
    firstSlotNumber: number;
    numSlots: number;
    validator: string;
    publicKey: string;
}
interface PenalizedSlots {
    blockNumber: number;
    disabled: number[];
}
interface InherentReward {
    type: InherentType.Reward;
    blockNumber: number;
    blockTime: number;
    validatorAddress: string;
    target: string;
    value: number;
    hash: string;
}
interface InherentPenalize {
    type: InherentType.Penalize;
    blockNumber: number;
    blockTime: number;
    validatorAddress: string;
    offenseEventBlock: number;
}
interface InherentJail {
    type: InherentType.Jail;
    blockNumber: number;
    blockTime: number;
    validatorAddress: string;
    offenseEventBlock: number;
}
type Inherent = InherentReward | InherentPenalize | InherentJail;
interface MempoolInfo {
    _0?: number;
    _1?: number;
    _2?: number;
    _5?: number;
    _10?: number;
    _20?: number;
    _50?: number;
    _100?: number;
    _200?: number;
    _500?: number;
    _1000?: number;
    _2000?: number;
    _5000?: number;
    _10000?: number;
    total: number;
    buckets: number[];
}
interface WalletAccount {
    address: string;
    publicKey: string;
    privateKey: string;
}
interface Signature {
    signature: string;
    publicKey: string;
}
interface ZKPState {
    latestBlock: Block;
    latestProof?: string;
}
interface BlockchainState {
    blockNumber: number;
    blockHash: string;
}
interface Auth {
    username: string;
    password: string;
}
declare enum BlockType {
    Micro = "micro",
    Macro = "macro"
}
declare enum BlockSubscriptionType {
    Macro = "macro",
    Micro = "micro",
    Election = "election"
}
declare enum RetrieveType {
    Full = "full",
    Partial = "partial",
    Hash = "hash"
}
declare enum NetworkId {
    Test = 1,
    Dev = 2,
    Bounty = 3,
    Dummy = 4,
    Main = 42,
    TestAlbatross = 5,
    DevAlbatross = 6,
    UnitAlbatross = 7,
    MainAlbatross = 24
}
interface ForkProof {
    blockNumber: number;
    hashes: [string, string];
}
interface DoubleProposalProof {
    blockNumber: number;
    hashes: [string, string];
}
interface DoubleVoteProof {
    blockNumber: number;
}
type EquivocationProof = {
    type: 'Fork';
    proof: ForkProof;
} | {
    type: 'DoubleProposal';
    proof: DoubleProposalProof;
} | {
    type: 'DoubleVote';
    proof: DoubleVoteProof;
};
interface PartialBlock {
    hash: string;
    size: number;
    batch: number;
    version: number;
    number: number;
    timestamp: number;
    parentHash: string;
    seed: string;
    extraData: string;
    stateHash: string;
    bodyHash?: string;
    historyHash: string;
    network: NetworkId;
    transactions?: Transaction[];
}
interface PartialMicroBlock extends PartialBlock {
    type: BlockType.Micro;
    producer: {
        slotNumber: number;
        validator: string;
        publicKey: string;
    };
    justification: {
        micro: string;
    } | {
        skip: {
            sig: {
                signature: {
                    signature: string;
                };
                signers: number[];
            };
        };
    };
    equivocationProofs?: EquivocationProof[];
    epoch: number;
    parentElectionHash?: undefined;
}
interface MicroBlock extends PartialMicroBlock {
    transactions: Transaction[];
    isElectionBlock?: undefined;
    lostRewardSet?: number[];
    disabledSet?: number[];
    interlink?: undefined;
    slots?: undefined;
    nextBatchInitialPunishedSet?: undefined;
}
interface PartialMacroBlock extends PartialBlock {
    type: BlockType.Macro;
    epoch: number;
    parentElectionHash: string;
    producer?: undefined;
    equivocationProofs?: undefined;
}
interface MacroBlock extends PartialMacroBlock {
    isElectionBlock: false;
    transactions: Transaction[];
    lostRewardSet: number[];
    disabledSet: number[];
    justification?: {
        round: number;
        sig: {
            signature: {
                signature: string;
            };
            signers: number[];
        };
    };
    interlink?: undefined;
    slots?: undefined;
    nextBatchInitialPunishedSet?: undefined;
}
interface ElectionMacroBlock extends PartialMacroBlock {
    isElectionBlock: true;
    transactions: Transaction[];
    interlink: string[];
    slots: Slot[];
    nextBatchInitialPunishedSet: number[];
}
type Block = MicroBlock | MacroBlock | ElectionMacroBlock;

export { AccountType as A, type BasicAccount as B, type DoubleProposalProof as D, type EquivocationProof as E, type ForkProof as F, HashAlgorithm as H, InherentType as I, type MempoolInfo as M, type PolicyConstants as P, RetrieveType as R, type StakingAccount as S, type Transaction as T, type ValidityStartHeight as V, type WalletAccount as W, type ZKPState as Z, type VestingAccount as a, type HtlcAccount as b, type Account as c, type Staker as d, type Validator as e, type Slot as f, type PenalizedSlots as g, type InherentReward as h, type InherentPenalize as i, type InherentJail as j, type Inherent as k, type Signature as l, type BlockchainState as m, type Auth as n, BlockType as o, BlockSubscriptionType as p, type DoubleVoteProof as q, type PartialBlock as r, type PartialMicroBlock as s, type MicroBlock as t, type PartialMacroBlock as u, type MacroBlock as v, type ElectionMacroBlock as w, type Block as x };