/// <reference types="node" />
import { AccountAddressT, DeriveHWSigningKeyInput, DeriveNextInput, SigningKeychainT } from "../account/index";
import { AmountT, Network } from "../primitives/index";
import * as fromApi from "./api/index";
import { Observable } from "rxjs";
import { KeystoreT, MnemomicT } from "../crypto/index";
import { AddAccountByPrivateKeyInput, AccountsT, WalletT, AccountT, MakeTransactionOptions, SwitchAccountInput, TxMessage } from "./_types";
import { LogLevel, RadixError } from "../util/index";
import { ExecutedTransaction, SimpleExecutedTransaction, TransactionHistory, TransactionIdentifierT } from "./dto/index";
import { Result, ResultAsync } from "neverthrow";
import { ResourceIdentifierT, ValidatorAddressT } from "../account/index";
import { SendTxOutput } from "./transaction/_types";
export declare const Radix: {
    create: () => {
        api: () => Promise<{
            validators: (network: string) => ResultAsync<import("./api/open-api/_types").ValidatorsEndpoint.DecodedResponse, RadixError[]>;
            lookupValidator: (input: ValidatorAddressT) => ResultAsync<{
                address: ValidatorAddressT;
                ownerAddress: AccountAddressT;
                name: string;
                infoURL?: URL | undefined;
                totalDelegatedStake: AmountT;
                ownerDelegation: AmountT;
                validatorFee: number;
                registered: boolean;
                isExternalStakeAccepted: boolean;
                uptimePercentage: number;
                proposalsMissed: number;
                proposalsCompleted: number;
            }, RadixError[]>;
            networkId: () => ResultAsync<import("./api/open-api/_types").GatewayEndpoint.DecodedResponse, RadixError[]>;
            tokenBalancesForAddress: (address: AccountAddressT) => ResultAsync<import("./api/open-api/_types").AccountBalancesEndpoint.DecodedResponse, RadixError[]>;
            transactionHistory: ({ address, size: limit, cursor, }: import("./dto").TransactionHistoryRequestInput) => ResultAsync<import("./dto").SimpleTransactionHistory, RadixError[]>;
            nativeToken: (input: import("@networking").TokenNativeRequest) => ResultAsync<import("./dto").Token, RadixError[]>;
            tokenInfo: (rri: Readonly<{
                hash: Buffer;
                __witness: "isRRI";
                network: Network;
                name: string;
                toPrimitive: () => string;
                equals: (other: Readonly<any>) => boolean;
            }>) => ResultAsync<import("./dto").Token, RadixError[]>;
            stakesForAddress: (address: AccountAddressT) => ResultAsync<import("./api/open-api/_types").StakePositionsEndpoint.DecodedResponse, RadixError[]>;
            unstakesForAddress: (address: AccountAddressT) => ResultAsync<import("./api/open-api/_types").UnstakePositionsEndpoint.DecodedResponse, RadixError[]>;
            transactionStatus: (txID: Readonly<{
                __witness: "isTXId";
                __hex: string;
                toPrimitive: () => string;
                equals: (other: Readonly<any>) => boolean;
            }>, network: string) => ResultAsync<SimpleExecutedTransaction, RadixError[]>;
            buildTransaction: (from: AccountAddressT) => (transactionIntent: import("./dto").TransactionIntent) => ResultAsync<import("./dto").BuiltTransaction, RadixError[]>;
            finalizeTransaction: (network: string, signedTransaction: import("./dto").SignedTransaction) => ResultAsync<import("./dto").FinalizedTransaction, RadixError[]>;
            submitSignedTransaction: (network: string, finalizedTx: import("./dto").FinalizedTransaction) => ResultAsync<import("./dto").PendingTransaction, RadixError[]>;
        } | fromApi.RadixAPI>;
        __wallet: Observable<Readonly<{
            revealMnemonic: () => MnemomicT;
            restoreLocalHDAccountsToIndex: (index: number) => Observable<Readonly<{
                getAccountWithHDSigningKeyByHDPath: (hdPath: import("@crypto").HDPathRadixT) => import("prelude-ts").Option<AccountT>;
                getAnyAccountByPublicKey: (publicKey: Readonly<{
                    __hex: string;
                    asData: (input: {
                        readonly compressed: boolean;
                    }) => Buffer;
                    toString: (compressed?: boolean | undefined) => string;
                    isValidSignature: (input: Readonly<{
                        signature: import("@crypto").SignatureT;
                        hashedMessage: Buffer;
                    }>) => boolean;
                    decodeToPointOnCurve: () => Readonly<{
                        x: import("@radixdlt/uint256").UInt256;
                        y: import("@radixdlt/uint256").UInt256;
                        toBuffer: (includePrefixByte?: boolean | undefined) => Buffer;
                        toString: (includePrefixByte?: boolean | undefined) => string;
                        equals: (other: Readonly<any>) => boolean;
                        add: (other: Readonly<any>) => Readonly<any>;
                        multiply: (by: import("@radixdlt/uint256").UInt256) => Readonly<any>;
                        multiplyWithPrivateKey: (privateKey: import("@crypto").PrivateKeyT) => Readonly<any>;
                    }>;
                    equals: (other: Readonly<any>) => boolean;
                }>) => import("prelude-ts").Option<AccountT>;
                all: AccountT[];
                accountsWithNonHDSigningKeys: () => AccountT[];
                accountsWithLocalHDSigningKeys: () => AccountT[];
                accountsWithHardwareHDSigningKeys: () => AccountT[];
                accountsWithHDSigningKeys: () => AccountT[];
                size: () => number;
            }>>;
            deriveNextLocalHDAccount: (input?: DeriveNextInput) => Observable<AccountT>;
            deriveHWAccount: (input: DeriveHWSigningKeyInput) => Observable<AccountT>;
            displayAddressForActiveHWAccountOnHWDeviceForVerification: () => Observable<void>;
            addAccountFromPrivateKey: (input: import("@account").AddSigningKeyByPrivateKeyInput) => Observable<AccountT>;
            switchAccount: (input: SwitchAccountInput) => AccountT;
            observeActiveAccount: () => Observable<AccountT>;
            observeAccounts: () => Observable<Readonly<{
                getAccountWithHDSigningKeyByHDPath: (hdPath: import("@crypto").HDPathRadixT) => import("prelude-ts").Option<AccountT>;
                getAnyAccountByPublicKey: (publicKey: Readonly<{
                    __hex: string;
                    asData: (input: {
                        readonly compressed: boolean;
                    }) => Buffer;
                    toString: (compressed?: boolean | undefined) => string;
                    isValidSignature: (input: Readonly<{
                        signature: import("@crypto").SignatureT;
                        hashedMessage: Buffer;
                    }>) => boolean;
                    decodeToPointOnCurve: () => Readonly<{
                        x: import("@radixdlt/uint256").UInt256;
                        y: import("@radixdlt/uint256").UInt256;
                        toBuffer: (includePrefixByte?: boolean | undefined) => Buffer;
                        toString: (includePrefixByte?: boolean | undefined) => string;
                        equals: (other: Readonly<any>) => boolean;
                        add: (other: Readonly<any>) => Readonly<any>;
                        multiply: (by: import("@radixdlt/uint256").UInt256) => Readonly<any>;
                        multiplyWithPrivateKey: (privateKey: import("@crypto").PrivateKeyT) => Readonly<any>;
                    }>;
                    equals: (other: Readonly<any>) => boolean;
                }>) => import("prelude-ts").Option<AccountT>;
                all: AccountT[];
                accountsWithNonHDSigningKeys: () => AccountT[];
                accountsWithLocalHDSigningKeys: () => AccountT[];
                accountsWithHardwareHDSigningKeys: () => AccountT[];
                accountsWithHDSigningKeys: () => AccountT[];
                size: () => number;
            }>>;
        }>>;
        __reset: () => void;
        __withNodeConnection: (url$: Observable<URL>) => any;
        __withAPI: (RadixAPI$: Observable<fromApi.RadixAPI>) => any;
        __withWallet: (wallet: WalletT) => any;
        __withKeychain: (signingKeychain: SigningKeychainT) => any;
        connect: (url: string) => Promise<void>;
        withKeystore: (keystore: KeystoreT, password: string) => Promise<Result<void, Error>>;
        login: (password: string, loadKeystore: () => Promise<KeystoreT>) => any;
        deriveNextAccount: (input?: DeriveNextInput) => any;
        deriveHWAccount: (input: DeriveHWSigningKeyInput) => Observable<AccountT>;
        displayAddressForActiveHWAccountOnHWDeviceForVerification: () => Observable<void>;
        addAccountFromPrivateKey: (input: AddAccountByPrivateKeyInput) => any;
        switchAccount: (input: SwitchAccountInput) => any;
        restoreLocalHDAccountsToIndex: (index: number) => Observable<AccountsT>;
        decryptTransaction: (input: SimpleExecutedTransaction) => Observable<string>;
        logLevel: (level: LogLevel) => any;
        transactionStatus: (txID: TransactionIdentifierT, trigger: Observable<number>) => Observable<SimpleExecutedTransaction>;
        revealMnemonic: () => Observable<MnemomicT>;
        activeAddress: Observable<Readonly<{
            addressType: import("@account").AddressTypeT;
            network: Network;
            publicKey: Readonly<{
                __hex: string;
                asData: (input: {
                    readonly compressed: boolean;
                }) => Buffer;
                toString: (compressed?: boolean | undefined) => string;
                isValidSignature: (input: Readonly<{
                    signature: import("@crypto").SignatureT;
                    hashedMessage: Buffer;
                }>) => boolean;
                decodeToPointOnCurve: () => Readonly<{
                    x: import("@radixdlt/uint256").UInt256;
                    y: import("@radixdlt/uint256").UInt256;
                    toBuffer: (includePrefixByte?: boolean | undefined) => Buffer;
                    toString: (includePrefixByte?: boolean | undefined) => string;
                    equals: (other: Readonly<any>) => boolean;
                    add: (other: Readonly<any>) => Readonly<any>;
                    multiply: (by: import("@radixdlt/uint256").UInt256) => Readonly<any>;
                    multiplyWithPrivateKey: (privateKey: import("@crypto").PrivateKeyT) => Readonly<any>;
                }>;
                equals: (other: Readonly<any>) => boolean;
            }>;
            toPrimitive: () => string;
            equals: (other: Readonly<any>) => boolean;
        }> & Readonly<{
            addressType: import("@account").AddressTypeT.ACCOUNT;
            equals: (other: AccountAddressT) => boolean;
        }>>;
        activeAccount: Observable<AccountT>;
        accounts: Observable<Readonly<{
            getAccountWithHDSigningKeyByHDPath: (hdPath: import("@crypto").HDPathRadixT) => import("prelude-ts").Option<AccountT>;
            getAnyAccountByPublicKey: (publicKey: Readonly<{
                __hex: string;
                asData: (input: {
                    readonly compressed: boolean;
                }) => Buffer;
                toString: (compressed?: boolean | undefined) => string;
                isValidSignature: (input: Readonly<{
                    signature: import("@crypto").SignatureT;
                    hashedMessage: Buffer;
                }>) => boolean;
                decodeToPointOnCurve: () => Readonly<{
                    x: import("@radixdlt/uint256").UInt256;
                    y: import("@radixdlt/uint256").UInt256;
                    toBuffer: (includePrefixByte?: boolean | undefined) => Buffer;
                    toString: (includePrefixByte?: boolean | undefined) => string;
                    equals: (other: Readonly<any>) => boolean;
                    add: (other: Readonly<any>) => Readonly<any>;
                    multiply: (by: import("@radixdlt/uint256").UInt256) => Readonly<any>;
                    multiplyWithPrivateKey: (privateKey: import("@crypto").PrivateKeyT) => Readonly<any>;
                }>;
                equals: (other: Readonly<any>) => boolean;
            }>) => import("prelude-ts").Option<AccountT>;
            all: AccountT[];
            accountsWithNonHDSigningKeys: () => AccountT[];
            accountsWithLocalHDSigningKeys: () => AccountT[];
            accountsWithHardwareHDSigningKeys: () => AccountT[];
            accountsWithHDSigningKeys: () => AccountT[];
            size: () => number;
        }>>;
        tokenBalances: () => Promise<ResultAsync<import("./api/open-api/_types").Decoded.AccountBalances, RadixError[]>>;
        stakingPositions: () => Promise<ResultAsync<import("./api/open-api/_types").StakePositionsEndpoint.DecodedResponse, RadixError[]>>;
        unstakingPositions: () => Promise<ResultAsync<import("./api/open-api/_types").UnstakePositionsEndpoint.DecodedResponse, RadixError[]>>;
        lookupTransaction: (txID: Readonly<{
            __witness: "isTXId";
            __hex: string;
            toPrimitive: () => string;
            equals: (other: Readonly<any>) => boolean;
        }>) => Promise<ResultAsync<ExecutedTransaction, Error[] | RadixError[]>>;
        transactionHistory: (size: number, cursor?: string | undefined) => Promise<Result<TransactionHistory, RadixError[]>>;
        transferTokens: (to: AccountAddressT, amount: AmountT, tokenIdentifier: ResourceIdentifierT, message?: TxMessage | undefined, options?: MakeTransactionOptions) => Promise<Result<SendTxOutput, Error[]>>;
        stakeTokens: (validator: ValidatorAddressT, amount: AmountT, options?: MakeTransactionOptions) => Promise<Result<SendTxOutput, Error[]>>;
        unstakeTokens: (validator: ValidatorAddressT, amount: AmountT, options?: MakeTransactionOptions) => Promise<Result<SendTxOutput, Error[]>>;
        validators: () => Promise<Result<import("./api/open-api/_types").ValidatorsEndpoint.DecodedResponse, RadixError[]>>;
        lookupValidator: (input: ValidatorAddressT) => Promise<ResultAsync<{
            address: ValidatorAddressT;
            ownerAddress: AccountAddressT;
            name: string;
            infoURL?: URL | undefined;
            totalDelegatedStake: AmountT;
            ownerDelegation: AmountT;
            validatorFee: number;
            registered: boolean;
            isExternalStakeAccepted: boolean;
            uptimePercentage: number;
            proposalsMissed: number;
            proposalsCompleted: number;
        }, RadixError[]>>;
        targetApiVersion: string;
    };
};
//# sourceMappingURL=radix.d.ts.map