import { Principal } from '@dfinity/principal';
import { _SERVICE as LedgerAPI, AccountType, AssetId, GlobalId, IdSelector, RemoteSelector, SubId, VirId } from '../../candid/ledger';
import { Delegate } from './delegate';
import { JsAccountInfo, JsAccountState } from './types';
import { QueryRetryInterceptorErrorCallback } from './call-interceptors';
export type TxResult = any;
export type TxLedStatus = {
    status: 'dropped';
} | {
    status: 'awaited';
} | {
    status: 'processed';
    result: TxResult | null;
};
export type StreamStatus = {
    closed: boolean;
    source: {
        type: 'internal';
    } | {
        type: 'aggregator';
        principal: Principal;
    };
    length: bigint;
    lastActive: bigint;
};
export declare class LedgerDelegate extends Delegate<LedgerAPI> {
    protected readonly _canisterPrincipal: Principal | string;
    constructor(_canisterPrincipal: Principal | string, network: 'ic' | 'local');
    accountInfo(selector: IdSelector): Promise<Array<[bigint, JsAccountInfo]>>;
    nAccounts(): Promise<bigint>;
    nVirtualAccounts(): Promise<bigint>;
    virtualAccountInfo(selector: IdSelector): Promise<Array<[bigint, {
        type: 'ft';
        assetId: AssetId;
        accessPrincipal: Principal;
    } | null]>>;
    remoteAccountInfo(selector: RemoteSelector): Promise<Array<[[Principal, VirId], {
        type: 'ft';
        assetId: AssetId;
    } | null]>>;
    createFungibleToken(decimals: number, description: string): Promise<bigint>;
    openAccounts(accountTypes: AccountType[]): Promise<{
        first: bigint;
    }>;
    openVirtualAccounts(args: {
        accountType: {
            type: 'ft';
            assetId: AssetId;
        };
        accessPrincipal: Principal | string;
        assetState: {
            type: 'ft';
            balance: bigint;
        };
        backingAccount: SubId;
        expiration?: number;
    }[]): Promise<{
        first: VirId;
    }>;
    openVirtualAccount(accountType: {
        type: 'ft';
        assetId: AssetId;
    }, accessPrincipal: Principal | string, assetState: {
        type: 'ft';
        balance: bigint;
    }, backingAccount: SubId, expiration?: number): Promise<{
        id: VirId;
    }>;
    updateVirtualAccounts(args: {
        vid: VirId;
        updates: {
            backingAccount?: SubId;
            state?: {
                ft_set: bigint;
            } | {
                ft_dec: bigint;
            } | {
                ft_inc: bigint;
            };
            expiration?: number;
        };
    }[]): Promise<{
        type: 'ft';
        balance: bigint;
        delta: bigint;
    }[]>;
    updateVirtualAccount(vid: VirId, updates: {
        backingAccount?: SubId;
        state?: {
            ft_set: bigint;
        } | {
            ft_dec: bigint;
        } | {
            ft_inc: bigint;
        };
        expiration?: number;
    }): Promise<{
        type: 'ft';
        balance: bigint;
        delta: bigint;
    }>;
    deleteVirtualAccounts(vids: [VirId]): Promise<{
        type: 'ft';
        balance: bigint;
    }[]>;
    deleteVirtualAccount(vid: VirId): Promise<{
        type: 'ft';
        balance: bigint;
    }>;
    feeRatio(): Promise<bigint>;
    private castTxStatusResponse;
    txStatus(gids: GlobalId[], retryErrorCallback?: QueryRetryInterceptorErrorCallback): Promise<TxLedStatus[]>;
    singleTxStatus(id: GlobalId, retryErrorCallback?: QueryRetryInterceptorErrorCallback): Promise<TxLedStatus>;
    timestampedSingleTxStatus(id: GlobalId, retryErrorCallback?: QueryRetryInterceptorErrorCallback): Promise<[TxLedStatus, number]>;
    nFtAssets(): Promise<bigint>;
    ftInfo(selector: IdSelector): Promise<Array<[AssetId, {
        controller: Principal;
        decimals: number;
        description: string;
    }]>>;
    aggregators(): Promise<{
        principal: Principal;
        priority: number;
    }[]>;
    aggregatorPrincipal(streamId: bigint): Promise<Principal | null>;
    nStreams(): Promise<bigint>;
    streamStatus(selector: IdSelector): Promise<Array<[bigint, StreamStatus]>>;
    state(arg: {
        ftSupplies?: IdSelector;
        virtualAccounts?: IdSelector;
        accounts?: IdSelector;
        remoteAccounts?: RemoteSelector;
    }): Promise<{
        ftSupplies: Array<[AssetId, bigint]>;
        virtualAccounts: Array<[VirId, {
            state: JsAccountState;
            backingSubaccountId: bigint;
            expiration: bigint;
        }]>;
        accounts: Array<[SubId, JsAccountState]>;
        remoteAccounts: Array<[[Principal, VirId], {
            state: JsAccountState;
            expiration: bigint;
        } | null]>;
    }>;
}