import { ABI, Action, AnyAction, Asset, Authority, Blob, BlockId, BlockTimestamp, Bytes, Checksum160, Checksum256, Float128, Float64, Int32, Int64, KeyWeight, Name, NameType, PermissionLevel, PublicKey, PublicKeyType, Signature, Struct, TimePoint, Transaction, TransactionHeader, TransactionReceipt, UInt128, UInt16, UInt32, UInt32Type, UInt64, Weight } from "../../chain/index.js";
import { ABISerializableObject, ABISerializableType } from "../../serializer/index.js";
export declare class AccountLinkedAction extends Struct {
    account: Name;
    action: Name;
}
export declare class AccountPermission extends Struct {
    perm_name: Name;
    parent: Name;
    required_auth: Authority;
    linked_actions: AccountLinkedAction[];
}
export declare class AccountResourceLimit extends Struct {
    used: Int64;
    available: Int64;
    max: Int64;
    last_usage_update_time: TimePoint;
    current_used: Int64;
}
export declare class AccountTotalResources extends Struct {
    owner: Name;
    net_weight: Asset;
    cpu_weight: Asset;
    ram_bytes: UInt64;
}
export declare class AccountSelfDelegatedBandwidth extends Struct {
    from: Name;
    to: Name;
    net_weight: Asset;
    cpu_weight: Asset;
}
export declare class AccountRefundRequest extends Struct {
    owner: Name;
    request_time: TimePoint;
    net_amount: Asset;
    cpu_amount: Asset;
}
export declare class AccountVoterInfo extends Struct {
    owner: Name;
    proxy: Name;
    producers: Name[];
    staked?: Int64;
    last_vote_weight: Float64;
    proxied_vote_weight: Float64;
    is_proxy: boolean;
    flags1?: UInt32;
    reserved2: UInt32;
    reserved3: string;
}
export declare class AccountRexInfoMaturities extends Struct {
    /** Expected results from after SYSIO.Contracts v1.9.0 */
    key?: TimePoint;
    value?: Int64;
    /** Expected results from before SYSIO.Contracts v1.9.0 */
    first?: TimePoint;
    second?: Int64;
}
export declare class AccountRexInfo extends Struct {
    version: UInt32;
    owner: Name;
    vote_stake: Asset;
    rex_balance: Asset;
    matured_rex: Int64;
    rex_maturities: AccountRexInfoMaturities[];
}
export interface GetAbiResponse {
    account_name: string;
    abi?: ABI.Def;
}
export declare class GetRawAbiResponse extends Struct {
    account_name: Name;
    code_hash: Checksum256;
    abi_hash: Checksum256;
    abi: Blob;
}
export declare class AccountObject extends Struct {
    /** The account name of the retrieved account */
    account_name: Name;
    /** Highest block number on the chain */
    head_block_num: UInt32;
    /** Highest block unix timestamp. */
    head_block_time: TimePoint;
    /** Indicator of if this is a privileged system account */
    privileged: boolean;
    /** Last update to accounts contract as unix timestamp. */
    last_code_update: TimePoint;
    /** Account created as unix timestamp. */
    created: TimePoint;
    /** Account core token balance */
    core_liquid_balance?: Asset;
    ram_quota: Int64;
    net_weight: Int64;
    cpu_weight: Int64;
    net_limit: AccountResourceLimit;
    cpu_limit: AccountResourceLimit;
    subjective_cpu_bill_limit: AccountResourceLimit;
    ram_usage: UInt64;
    permissions: AccountPermission[];
    total_resources: AccountTotalResources;
    self_delegated_bandwidth?: AccountSelfDelegatedBandwidth;
    refund_request?: AccountRefundRequest;
    voter_info?: AccountVoterInfo;
    rex_info?: AccountRexInfo;
    getPermission(permission: NameType): AccountPermission;
}
export declare class AccountByAuthorizersRow extends Struct {
    account_name: Name;
    permission_name: Name;
    authorizing_key: PublicKey;
    authorizing_account: PermissionLevel;
    weight: Weight;
    threshold: UInt32;
}
export declare class AccountsByAuthorizers extends Struct {
    accounts: AccountByAuthorizersRow[];
}
export declare class NewProducersEntry extends Struct {
    producer_name: Name;
    block_signing_key: PublicKey;
}
export declare class NewProducers extends Struct {
    version: UInt32;
    producers: NewProducersEntry;
}
export declare class BlockExtension extends Struct {
    type: UInt16;
    data: Bytes;
}
export declare class HeaderExtension extends Struct {
    type: UInt16;
    data: Bytes;
}
export declare class TrxVariant implements ABISerializableObject {
    readonly id: Checksum256;
    readonly extra: Record<string, any>;
    static abiName: string;
    static from(data: any): TrxVariant;
    constructor(id: Checksum256, extra: Record<string, any>);
    get transaction(): Transaction | undefined;
    get signatures(): Signature[] | undefined;
    equals(other: any): boolean;
    toJSON(): Checksum256;
}
export declare class GetBlockResponseTransactionReceipt extends TransactionReceipt {
    trx: TrxVariant;
    get id(): Checksum256;
}
export declare class GetBlockResponse extends Struct {
    timestamp: TimePoint;
    producer: Name;
    confirmed: UInt16;
    previous: BlockId;
    transaction_mroot: Checksum256;
    action_mroot: Checksum256;
    schedule_version: UInt32;
    new_producers?: NewProducers;
    header_extensions?: HeaderExtension[];
    new_protocol_features?: any;
    producer_signature: Signature;
    transactions: GetBlockResponseTransactionReceipt[];
    block_extensions: BlockExtension[];
    id: BlockId;
    block_num: UInt32;
    ref_block_prefix: UInt32;
}
export declare class GetBlockInfoResponse extends Struct {
    block_num: UInt32;
    ref_block_num: UInt16;
    id: BlockId;
    timestamp: TimePoint;
    producer: Name;
    confirmed: UInt16;
    previous: BlockId;
    transaction_mroot: Checksum256;
    action_mroot: Checksum256;
    schedule_version: UInt32;
    producer_signature: Signature;
    ref_block_prefix: UInt32;
}
export declare class ActiveScheduleProducerAuthority extends Struct {
    producer_name: Name;
    authority: any;
}
export declare class ActiveScheduleProducer extends Struct {
    producer_name: Name;
    authority: ActiveScheduleProducerAuthority;
}
export declare class ActiveSchedule extends Struct {
    version: UInt32;
    producers: ActiveScheduleProducer[];
}
export declare class BlockStateHeader extends Struct {
    timestamp: TimePoint;
    producer: Name;
    confirmed: UInt16;
    previous: BlockId;
    transaction_mroot: Checksum256;
    action_mroot: Checksum256;
    schedule_version: UInt32;
    header_extensions?: any[];
    producer_signature: Signature;
}
export declare class GetBlockHeaderStateResponse extends Struct {
    block_num: UInt32;
    dpos_proposed_irreversible_blocknum: UInt32;
    dpos_irreversible_blocknum: UInt32;
    id: BlockId;
    header: BlockStateHeader;
    /** Unstructured any fields specific to header state calls */
    active_schedule: any;
    blockroot_merkle: any;
    producer_to_last_produced: any;
    producer_to_last_implied_irb: any;
    valid_block_signing_authority: any;
    confirm_count: any;
    pending_schedule: any;
    activated_protocol_features: any;
    additional_signatures: any;
}
export declare class GetInfoResponse extends Struct {
    /** Hash representing the last commit in the tagged release. */
    server_version: string;
    /** Hash representing the ID of the chain. */
    chain_id: Checksum256;
    /** Highest block number on the chain */
    head_block_num: UInt32;
    /** Highest block number on the chain that has been irreversibly applied to state. */
    last_irreversible_block_num: UInt32;
    /** Highest block ID on the chain that has been irreversibly applied to state. */
    last_irreversible_block_id: BlockId;
    /** Highest block ID on the chain. */
    head_block_id: BlockId;
    /** Highest block unix timestamp. */
    head_block_time: TimePoint;
    /** Producer that signed the highest block (head block). */
    head_block_producer: Name;
    /** CPU limit calculated after each block is produced, approximately 1000 times `blockCpuLimit`. */
    virtual_block_cpu_limit: UInt64;
    /** NET limit calculated after each block is produced, approximately 1000 times `blockNetLimit`. */
    virtual_block_net_limit: UInt64;
    /** Actual maximum CPU limit. */
    block_cpu_limit: UInt64;
    /** Actual maximum NET limit. */
    block_net_limit: UInt64;
    /** String representation of server version. */
    server_version_string?: string;
    /** Sequential block number representing the best known head in the fork database tree. */
    fork_db_head_block_num?: UInt32;
    /** Hash representing the best known head in the fork database tree. */
    fork_db_head_block_id?: BlockId;
    getTransactionHeader(secondsAhead?: number): TransactionHeader;
}
export interface PushTransactionResponse {
    transaction_id: string;
    processed: {
        id: string;
        block_num: number;
        block_time: string;
        receipt: {
            status: string;
            cpu_usage_us: number;
            net_usage_words: number;
        };
        elapsed: number;
        net_usage: number;
        scheduled: boolean;
        action_traces: any[];
        account_ram_delta: any;
    };
}
export interface SendTransactionResponseExceptionStack {
    context: {
        level: string;
        file: string;
        line: number;
        method: string;
        hostname: string;
        thread_name: string;
        timestamp: string;
    };
    format: string;
    data: any;
}
export interface SendTransactionResponseException {
    code: number;
    name: string;
    message: string;
    stack: SendTransactionResponseExceptionStack[];
}
export interface SendTransactionResponse {
    transaction_id: string;
    processed: {
        id: string;
        block_num: number;
        block_time: string;
        receipt: {
            status: string;
            cpu_usage_us: number;
            net_usage_words: number;
        };
        elapsed: number;
        except?: SendTransactionResponseException;
        net_usage: number;
        scheduled: boolean;
        action_traces: any[];
        account_ram_delta: any;
    };
}
export interface SendTransaction2Options {
    return_failure_trace?: boolean;
    retry_trx?: boolean;
    retry_trx_num_blocks?: number;
}
export interface SendTransaction2Response {
    transaction_id: string;
    processed: {
        id: string;
        block_num: number;
        block_time: string;
        receipt: {
            status: string;
            cpu_usage_us: number;
            net_usage_words: number;
        };
        elapsed: number;
        net_usage: number;
        scheduled: boolean;
        action_traces: any[];
        account_ram_delta: any;
    };
}
export interface TableIndexTypes {
    float128: Float128;
    float64: Float64;
    i128: UInt128;
    i64: UInt64;
    name: Name;
    ripemd160: Checksum160;
    sha256: Checksum256;
}
export type TableIndexType = Name | UInt64 | UInt128 | Float64 | Checksum256 | Checksum160;
export interface GetTableRowsParams<Index = TableIndexType | string> {
    /** The name of the smart contract that controls the provided table. */
    code: NameType;
    /** Name of the table to query. */
    table: NameType;
    /** The account to which this data belongs, if omitted will be set to be same as `code`. */
    scope?: string | TableIndexType;
    /** Lower lookup bound. */
    lower_bound?: Index;
    /** Upper lookup bound. */
    upper_bound?: Index;
    /** How many rows to fetch, defaults to 10 if unset. */
    limit?: UInt32Type;
    /** Whether to iterate records in reverse order. */
    reverse?: boolean;
    /** Position of the index used, defaults to primary. */
    index_position?: "primary" | "secondary" | "tertiary" | "fourth" | "fifth" | "sixth" | "seventh" | "eighth" | "ninth" | "tenth";
    /**
     * Whether node should try to decode row data using code abi.
     * Determined automatically based the `type` param if omitted.
     */
    json?: boolean;
    /**
     * Set to true to populate the ram_payers array in the response.
     */
    show_payer?: boolean;
}
export interface GetTableRowsParamsKeyed<Index = TableIndexType, Key = keyof TableIndexTypes> extends GetTableRowsParams<Index> {
    /** Index key type, determined automatically when passing a typed `upper_bound` or `lower_bound`. */
    key_type: Key;
}
export interface GetTableRowsParamsTyped<Index = TableIndexType | string, Row = ABISerializableType> extends GetTableRowsParams<Index> {
    /** Result type for each row. */
    type: Row;
}
export interface GetTableRowsResponse<Index = TableIndexType, Row = any> {
    rows: Row[];
    more: boolean;
    /**
     * Populated when `show_payer` is set. Each entry aligns with `rows[i]`.
     * The entry is `undefined` when the chain returned a row without a payer
     * (wire-sysio KV shape makes `payer` optional).
     */
    ram_payers?: (Name | undefined)[];
    next_key?: Index;
}
export interface GetTableByScopeParams {
    code: NameType;
    table?: NameType;
    lower_bound?: string;
    upper_bound?: string;
    limit?: UInt32Type;
    reverse?: boolean;
}
export declare class GetTableByScopeResponseRow extends Struct {
    code: Name;
    scope: Name;
    table: Name;
    payer: Name;
    count: UInt32;
}
export declare class GetTableByScopeResponse extends Struct {
    rows: GetTableByScopeResponseRow[];
    more: string;
}
export declare class OrderedActionsResult extends Struct {
    global_action_seq: UInt64;
    account_action_seq: Int64;
    block_num: UInt32;
    block_time: BlockTimestamp;
    action_trace?: any;
    irrevirsible?: boolean;
}
export declare class GetActionsResponse extends Struct {
    actions: OrderedActionsResult[];
    last_irreversible_block: Int32;
    head_block_num: Int32;
    time_limit_exceeded_error?: boolean;
}
export declare class TransactionAuthSequence extends Struct {
    account: string;
    sequence: string;
}
export declare class TransactionTraceReceipt extends Struct {
    act_digest: Checksum256;
    auth_sequence: TransactionAuthSequence[];
    global_sequence: string;
    receiver: Name;
    recv_sequence: string;
}
export declare class TransactionTrace extends Struct {
    account_ram_deltas: any[];
    act: Action;
    block_num: number;
    block_time: BlockTimestamp;
    console: string;
    context_free: boolean;
    elapsed: number;
    except: any;
    inline_traces: TransactionTrace[];
    producer_block_id: Checksum256;
    receipt: TransactionTraceReceipt;
    trx_id: Checksum256;
}
export declare class Trx extends Struct {
    actions: AnyAction[];
    context_free_actions: AnyAction[];
    context_free_data: any[];
    delay_sec: number;
    expiration: string;
    max_cpu_usage_ms: number;
    max_net_usage_words: number;
    ref_block_num: number;
    ref_block_prefix: number;
    signatures: string[];
}
export declare class TransactionInfo extends Struct {
    receipt: TransactionReceipt;
    trx: Trx;
}
export declare class GetTransactionResponse extends Struct {
    id: Checksum256;
    block_num: UInt32;
    block_time: BlockTimestamp;
    last_irreversible_block: UInt32;
    traces?: TransactionTrace[];
    trx: TransactionInfo;
}
export declare class GetKeyAccountsResponse extends Struct {
    account_names: Name[];
}
export declare class GetCodeResponse extends Struct {
    abi: ABI.Def;
    account_name: Name;
    code_hash: Checksum256;
    wast: string;
    wasm: string;
}
export declare class GetControlledAccountsResponse extends Struct {
    controlled_accounts: Name[];
}
export interface GetCurrencyStatsResponse {
    [key: string]: GetCurrencyStatsItemResponse;
}
export declare class GetCurrencyStatsItemResponse extends Struct {
    supply: Asset;
    max_supply: Asset;
    issuer: Name;
}
export declare class GetTransactionStatusResponse extends Struct {
    state: string;
    head_number: UInt32;
    head_id: BlockId;
    head_timestamp: TimePoint;
    irreversible_number: UInt32;
    irreversible_id: BlockId;
    irreversible_timestamp: TimePoint;
    earliest_tracked_block_id: BlockId;
    earliest_tracked_block_number: UInt32;
}
export declare class ProducerAuthority extends Struct {
    threshold: UInt32;
    keys: KeyWeight[];
}
export type ProducerEntry = [number, ProducerAuthority];
export declare class Producer extends Struct {
    producer_name: Name;
    authority: ProducerEntry;
    static from(data: any): Struct;
}
export declare class ProducerSchedule extends Struct {
    version: UInt32;
    producers: Producer[];
}
export declare class GetProducerScheduleResponse extends Struct {
    active: ProducerSchedule;
    pending: ProducerSchedule;
    proposed: ProducerSchedule;
}
export declare class ProtocolFeature extends Struct {
    feature_digest: Checksum256;
    activation_ordinal: UInt32;
    activation_block_num: UInt32;
    description_digest: Checksum256;
    dependencies: string[];
    protocol_feature_type: string;
    specification: any[];
}
export declare class GetProtocolFeaturesResponse extends Struct {
    activated_protocol_features: ProtocolFeature[];
    more: UInt32;
}
export interface GetProtocolFeaturesParams {
    /** Lower lookup bound. */
    lower_bound?: UInt32 | number;
    /** Upper lookup bound. */
    upper_bound?: UInt32 | number;
    /** How many rows to fetch, defaults to 10 if unset. */
    limit?: UInt32Type;
    /** Flag to indicate it is has to search by block number */
    search_by_block_num?: boolean;
    /** Whether to iterate records in reverse order. */
    reverse?: boolean;
}
export interface GetAccountsByAuthorizersParams {
    accounts?: NameType[];
    keys?: PublicKeyType[];
}
//# sourceMappingURL=Types.d.ts.map