import { Sha256Hash } from "../hash/sha256hash";
import { PublicAddress } from "../blockchain/ed_keys";
import { Block, BlockHeader } from "../blockchain/block";
import { Transaction, CommandReceipt, Receipt } from "../blockchain/transaction";
import { Stake } from "../blockchain/stake";
import { Option } from "../serde/option";
import { Serializable } from "../serde/serializable";
import { Enum, TypeCtorParams, u32, u64 } from "../constants";
export declare class SubmitTransactionRequest extends Serializable {
    transaction: Transaction;
    constructor({ transaction }: TypeCtorParams<SubmitTransactionRequest>);
}
export declare class SubmitTransactionResponse extends Serializable {
    error: Option<SubmitTransactionError>;
    constructor({ error }: TypeCtorParams<SubmitTransactionResponse>);
}
export declare enum SubmitTransactionError {
    UnacceptableNonce = 0,
    MempoolFull = 1,
    Other = 2
}
export declare class TransactionRequest extends Serializable {
    transaction_hash: Sha256Hash;
    include_receipt: boolean;
    constructor({ transaction_hash, include_receipt, }: TypeCtorParams<TransactionRequest>);
}
export declare class TransactionResponse extends Serializable {
    transaction: Option<Transaction>;
    receipt: Option<Receipt>;
    block_hash: Option<Sha256Hash>;
    position: Option<u32>;
    constructor({ transaction, receipt, block_hash, position, }: TypeCtorParams<TransactionResponse>);
}
export declare class TransactionPositionRequest extends Serializable {
    transaction_hash: Sha256Hash;
    constructor({ transaction_hash, }: TypeCtorParams<TransactionPositionRequest>);
}
export declare class TransactionPositionResponse extends Serializable {
    transaction_hash: Option<Sha256Hash>;
    block: Option<Sha256Hash>;
    position: Option<u32>;
    constructor({ transaction_hash, block, position, }: TypeCtorParams<TransactionPositionResponse>);
}
export declare class ReceiptRequest extends Serializable {
    transaction_hash: Sha256Hash;
    constructor({ transaction_hash }: TypeCtorParams<ReceiptRequest>);
}
export declare class ReceiptResponse extends Serializable {
    transaction_hash: Sha256Hash;
    receipt: Option<Receipt>;
    block_hash: Option<Sha256Hash>;
    position: Option<u32>;
    constructor({ transaction_hash, receipt, block_hash, position, }: TypeCtorParams<ReceiptResponse>);
}
export declare class BlockRequest extends Serializable {
    block_hash: Sha256Hash;
    constructor({ block_hash }: TypeCtorParams<BlockRequest>);
}
export declare class BlockResponse extends Serializable {
    block: Option<Block>;
    constructor({ block }: TypeCtorParams<BlockResponse>);
}
export declare class BlockHeaderRequest extends Serializable {
    block_hash: Sha256Hash;
    constructor({ block_hash }: TypeCtorParams<BlockHeaderRequest>);
}
export declare class BlockHeaderResponse extends Serializable {
    block_header: Option<BlockHeader>;
    constructor({ block_header }: TypeCtorParams<BlockHeaderResponse>);
}
export declare class BlockHeightByHashRequest extends Serializable {
    block_hash: Sha256Hash;
    constructor({ block_hash }: TypeCtorParams<BlockHeightByHashRequest>);
}
export declare class BlockHeightByHashResponse extends Serializable {
    block_hash: Sha256Hash;
    block_height: Option<u64>;
    constructor({ block_hash, block_height, }: TypeCtorParams<BlockHeightByHashResponse>);
}
export declare class BlockHashByHeightRequest extends Serializable {
    block_height: u64;
    constructor({ block_height }: TypeCtorParams<BlockHashByHeightRequest>);
}
export declare class BlockHashByHeightResponse extends Serializable {
    block_height: u64;
    block_hash: Option<Sha256Hash>;
    constructor({ block_height, block_hash, }: TypeCtorParams<BlockHashByHeightResponse>);
}
export declare class HighestCommittedBlockResponse extends Serializable {
    block_hash: Option<Sha256Hash>;
    constructor({ block_hash }: TypeCtorParams<HighestCommittedBlockResponse>);
}
export declare class StateRequest extends Serializable {
    accounts: Set<PublicAddress>;
    include_contract: boolean;
    storage_keys: Map<PublicAddress, Set<Uint8Array>>;
    constructor({ accounts, include_contract, storage_keys, }: TypeCtorParams<StateRequest>);
}
export declare class StateResponse extends Serializable {
    accounts: Map<PublicAddress, Account>;
    storage_tuples: Map<PublicAddress, Map<Uint8Array, Uint8Array>>;
    block_hash: Sha256Hash;
    constructor({ accounts, storage_tuples, block_hash, }: TypeCtorParams<StateResponse>);
}
export declare class ValidatorSetsRequest extends Serializable {
    include_prev: boolean;
    include_prev_delegators: boolean;
    include_curr: boolean;
    include_curr_delegators: boolean;
    include_next: boolean;
    include_next_delegators: boolean;
    constructor({ include_prev, include_prev_delegators, include_curr, include_curr_delegators, include_next, include_next_delegators, }: TypeCtorParams<ValidatorSetsRequest>);
}
export declare class ValidatorSetsResponse extends Serializable {
    prev_validator_set: Option<Option<ValidatorSet>>;
    curr_validator_set: Option<ValidatorSet>;
    next_validator_set: Option<ValidatorSet>;
    block_hash: Sha256Hash;
    constructor({ prev_validator_set, curr_validator_set, next_validator_set, block_hash, }: TypeCtorParams<ValidatorSetsResponse>);
}
export declare class PoolsRequest extends Serializable {
    operators: Set<PublicAddress>;
    include_stakes: boolean;
    constructor({ operators, include_stakes }: TypeCtorParams<PoolsRequest>);
}
export declare class PoolsResponse extends Serializable {
    pools: Map<PublicAddress, Option<Pool>>;
    block_hash: Sha256Hash;
    constructor({ pools, block_hash }: TypeCtorParams<PoolsResponse>);
}
export declare class StakesRequest extends Serializable {
    stakes: Set<[PublicAddress, PublicAddress]>;
    constructor({ stakes }: TypeCtorParams<StakesRequest>);
}
export declare class StakesResponse extends Serializable {
    stakes: Map<[PublicAddress, PublicAddress], Option<Stake>>;
    block_hash: Sha256Hash;
    constructor({ stakes, block_hash }: TypeCtorParams<StakesResponse>);
}
export declare class DepositsRequest extends Serializable {
    stakes: Set<[PublicAddress, PublicAddress]>;
    constructor({ stakes }: TypeCtorParams<DepositsRequest>);
}
export declare class DepositsResponse extends Serializable {
    deposits: Map<[PublicAddress, PublicAddress], Option<Deposit>>;
    block_hash: Sha256Hash;
    constructor({ deposits, block_hash }: TypeCtorParams<DepositsResponse>);
}
export declare class Deposit extends Serializable {
    owner: PublicAddress;
    balance: u64;
    auto_stake_rewards: boolean;
    constructor({ owner, balance, auto_stake_rewards }: TypeCtorParams<Deposit>);
}
export declare class Account extends Enum {
    accountWithContract?: AccountWithContract;
    accountWithoutContract?: AccountWithoutContract;
}
export declare class AccountWithContract extends Serializable {
    nonce: u64;
    balance: u64;
    contract: Option<Uint8Array>;
    cbi_version: Option<u32>;
    storage_hash: Option<Sha256Hash>;
    /**
     * @deprecated to be removed, check wrapper enum or instance type instead
     */
    static index: number;
    constructor({ nonce, balance, contract, cbi_version, storage_hash, }: TypeCtorParams<AccountWithContract>);
    index(): number;
}
export declare class AccountWithoutContract extends Serializable {
    nonce: u64;
    balance: u64;
    cbi_version: Option<u32>;
    storage_hash: Option<Sha256Hash>;
    static index: number;
    constructor({ nonce, balance, cbi_version, storage_hash, }: TypeCtorParams<AccountWithoutContract>);
    /**
     * @deprecated to be removed, check wrapper enum or instance type instead
     */
    index(): number;
}
export declare class ViewRequest extends Serializable {
    target: PublicAddress;
    method: Uint8Array;
    args: Option<Uint8Array[]>;
    constructor({ target, method, args }: TypeCtorParams<ViewRequest>);
}
export declare class ViewResponse extends Serializable {
    receipt: CommandReceipt;
    constructor({ receipt }: TypeCtorParams<ViewResponse>);
}
export declare class ValidatorSet extends Enum {
    poolsWithDelegator?: PoolWithDelegator[];
    poolsWithoutDelegator?: PoolWithoutDelegator[];
}
export declare class Pool extends Enum {
    poolWithDelegator?: PoolWithDelegator;
    poolWithoutDelegator?: PoolWithoutDelegator;
}
export declare class PoolWithDelegator extends Serializable {
    operator: PublicAddress;
    power: u64;
    commission_rate: number;
    operator_stake: Option<Stake>;
    delegated_stakes: Stake[];
    /**
     * @deprecated to be removed, check wrapper enum or instance type instead
     */
    static index: number;
    constructor({ operator, power, commission_rate, operator_stake, delegated_stakes, }: TypeCtorParams<PoolWithDelegator>);
    /**
     * @deprecated to be removed, check wrapper enum or instance type instead
     */
    index(): number;
}
export declare class PoolWithoutDelegator extends Serializable {
    operator: PublicAddress;
    power: u64;
    commission_rate: number;
    operator_stake: Option<Stake>;
    /**
     * @deprecated to be removed, check wrapper enum or instance type instead
     */
    static index: number;
    constructor({ operator, power, commission_rate, operator_stake, }: TypeCtorParams<PoolWithoutDelegator>);
    /**
     * @deprecated to be removed, check wrapper enum or instance type instead
     */
    index(): number;
}