import { TransactionExplanation as BaseTransactionExplanation, TransactionType as BitGoTransactionType, TssVerifyAddressOptions } from '@bitgo/sdk-core';
export declare const MAX_INGRESS_TTL: number;
export declare const PERMITTED_DRIFT: number;
export declare const LEDGER_CANISTER_ID: Uint8Array<ArrayBuffer>;
export declare const TESTNET_LEDGER_CANISTER_ID: Uint8Array<ArrayBuffer>;
export declare const ROOT_PATH = "m/0";
export declare const ACCOUNT_BALANCE_CALL = "icrc1_balance_of";
export declare const PUBLIC_NODE_REQUEST_ENDPOINT = "/api/v3/canister/";
export declare const DEFAULT_MEMO = 0;
export declare const ICRC1_FEE_KEY = "icrc1:fee";
export declare const METADATA_CALL = "icrc1_metadata";
export declare const DEFAULT_SUBACCOUNT = "0000000000000000000000000000000000000000000000000000000000000000";
export declare enum RequestType {
    CALL = "call"
}
export declare enum SignatureType {
    ECDSA = "ecdsa"
}
export declare enum CurveType {
    SECP256K1 = "secp256k1"
}
export declare enum OperationType {
    TRANSACTION = "TRANSACTION",
    FEE = "FEE"
}
export declare enum MethodName {
    SEND_PB = "send_pb"
}
export declare enum Network {
    ID = "00000000000000020101"
}
export declare enum TestNetwork {
    ID = "00000000010082fb0101"
}
export interface IcpTransactionData {
    senderAddress: string;
    receiverAddress: string;
    amount: string;
    fee: string;
    senderPublicKeyHex: string;
    memo: number | BigInt;
    transactionType: OperationType;
    expiryTime: number | BigInt;
}
export interface IcpPublicKey {
    hex_bytes: string;
    curve_type: string;
}
export interface IcpAccount {
    address: string;
}
export interface IcpCurrency {
    symbol: string;
    decimals: number;
}
export interface IcpAmount {
    value: string;
    currency: IcpCurrency;
}
export interface IcpOperation {
    type: string;
    account: IcpAccount;
    amount: IcpAmount;
}
export interface MetaData {
    created_at_time: number;
    memo: number | BigInt;
    ingress_start?: number | BigInt;
    ingress_end?: number | BigInt;
}
export interface IcpTransaction {
    public_keys: IcpPublicKey[];
    operations: IcpOperation[];
    metadata: MetaData;
}
export interface ParsedTransaction {
    operations: IcpOperation[];
    account_identifier_signers: IcpAccount[];
    metadata: MetaData;
}
export interface IcpAccountIdentifier {
    address: string;
}
export interface SendArgs {
    memo: {
        memo: number | BigInt;
    };
    payment: {
        receiverGets: {
            e8s: number;
        };
    };
    maxFee: {
        e8s: number;
    };
    to: {
        hash: Buffer;
    };
    createdAtTime: {
        timestampNanos: number;
    };
}
export interface HttpCanisterUpdate {
    canister_id: Uint8Array;
    method_name: MethodName;
    arg: Uint8Array;
    sender: Uint8Array;
    ingress_expiry: bigint;
}
export interface SigningPayload {
    account_identifier: IcpAccountIdentifier;
    hex_bytes: string;
    signature_type: SignatureType;
}
export interface PayloadsData {
    payloads: SigningPayload[];
    unsigned_transaction: string;
}
export interface Signatures {
    signing_payload: SigningPayload;
    signature_type: SignatureType;
    public_key: IcpPublicKey;
    hex_bytes: string;
}
export interface CborUnsignedTransaction {
    updates: [HttpCanisterUpdate][];
    ingress_expiries: bigint[];
}
export interface UpdateEnvelope {
    content: HttpCanisterUpdate & {
        request_type: RequestType;
    };
    sender_pubkey: Uint8Array;
    sender_sig: Uint8Array;
}
export interface RequestEnvelope {
    update: UpdateEnvelope;
}
/**
 * The transaction data returned from the toJson() function of a transaction
 */
export interface TxData {
    id?: string;
    sender: string;
    senderPublicKey: string;
    recipient: string;
    memo?: number | BigInt;
    feeAmount: string;
    expirationTime: number | BigInt;
    type?: BitGoTransactionType;
}
export interface IcpTransactionExplanation extends BaseTransactionExplanation {
    sender?: string;
    type?: BitGoTransactionType;
}
export interface NetworkIdentifier {
    blockchain: string;
    network: string;
}
export interface RawTransaction {
    serializedTxHex: PayloadsData;
    publicKey: string;
}
export interface RecoveryOptions {
    userKey: string;
    backupKey: string;
    bitgoKey?: string;
    rootAddress?: string;
    recoveryDestination: string;
    walletPassphrase: string;
    memo?: number | BigInt;
}
export interface RecoveryTransaction {
    id: string;
    tx: string;
}
export interface UnsignedSweepRecoveryTransaction {
    txHex: string;
    coin: string;
}
export interface PublicNodeSubmitResponse {
    status: string;
}
export interface AccountIdentifierHash {
    hash: Buffer<ArrayBuffer>;
}
export interface TransactionHexParams {
    transactionHex: string;
    signableHex?: string;
}
export interface TssVerifyIcpAddressOptions extends TssVerifyAddressOptions {
    rootAddress?: string;
    walletVersion?: number;
}
//# sourceMappingURL=iface.d.ts.map