import { Key, SerializedKeyPair } from 'openpgp';
import { EncryptionVersion, IEncryptionSession, IRequestTracer } from '../../../api';
import { type ITransactionRecipient, KeychainsTriplet, ParsedTransaction, TransactionParams } from '../../baseCoin';
import { ApiKeyShare, Keychain, WebauthnKeyEncryptionInfo } from '../../keychain';
import { ApiVersion, Memo, WalletType } from '../../wallet';
import { EDDSA, GShare, Signature, SignShare } from '../../../account-lib/mpc/tss';
import { Signature as EcdsaSignature } from '../../../account-lib/mpc/tss/ecdsa/types';
import { KeyShare } from './ecdsa';
import { EcdsaTypes } from '@bitgo/sdk-lib-mpc';
import { TssEcdsaStep1ReturnMessage, TssEcdsaStep2ReturnMessage, TxRequestChallengeResponse } from '../../tss/types';
import { AShare, DShare, SShare } from '../../tss/ecdsa/types';
import { MessageStandardType } from '../messageTypes';
export type TxRequestVersion = 'full' | 'lite';
export interface HopParams {
    paymentId?: string;
    userReqSig?: string;
    gasPriceMax?: number;
}
export interface EIP1559FeeOptions {
    gasLimit?: number;
    maxFeePerGas: number;
    maxPriorityFeePerGas: number;
    feeToken?: string;
}
export interface FeeOption {
    unit?: 'baseUnit' | 'cpu' | 'ram';
    formula?: 'fixed' | 'feeRate' | 'perKB' | 'custom' | 'perVKB';
    feeType?: 'base' | 'max' | 'tip';
    gasLimit?: number;
    gasPrice?: number;
    feeToken?: string;
}
export interface TokenEnablement {
    name: string;
    address?: string;
}
export interface SolInstruction {
    programId: string;
    keys: Array<{
        pubkey: string;
        isSigner: boolean;
        isWritable: boolean;
    }>;
    data: string;
}
export interface SolVersionedInstruction {
    programIdIndex: number;
    accountKeyIndexes: number[];
    data: string;
}
export interface SolAddressLookupTable {
    accountKey: string;
    writableIndexes: number[];
    readonlyIndexes: number[];
}
export interface SolVersionedTransactionData {
    versionedInstructions: SolVersionedInstruction[];
    addressLookupTables: SolAddressLookupTable[];
    staticAccountKeys: string[];
    messageHeader: {
        numRequiredSignatures: number;
        numReadonlySignedAccounts: number;
        numReadonlyUnsignedAccounts: number;
    };
    recentBlockhash?: string;
}
export interface aptosCustomTransactionParams {
    moduleName: string;
    functionName: string;
    typeArguments?: string[];
    functionArguments?: any[];
    abi?: any;
}
export interface CantonCreateCommand {
    CreateCommand: {
        templateId: string;
        createArguments: Record<string, unknown>;
    };
}
export interface CantonExerciseCommand {
    ExerciseCommand: {
        templateId: string;
        contractId?: string;
        choice: string;
        choiceArgument: Record<string, unknown>;
    };
}
export type CantonCommand = CantonCreateCommand | CantonExerciseCommand;
export interface CantonCommandResolveContractSpec {
    templateId: string;
    actAs: string[];
    readAs?: string[];
    injectAs: string;
    resolveAll?: boolean;
}
export interface CantonCommandParams {
    command: CantonCommand;
    actAs: string[];
    readAs?: string[];
    resolveContracts?: CantonCommandResolveContractSpec[];
}
export declare enum ShareType {
    R = "R",
    Commitment = "commitment",
    G = "G",
    S = "S",
    K = "K",
    MuDelta = "MuDelta",
    PaillierModulus = "PaillierModulus",
    MPCv2Round1 = "MPCv2Round1",
    MPCv2Round2 = "MPCv2Round2",
    MPCv2Round3 = "MPCv2Round3",
    EddsaMPCv2Round1 = "EddsaMPCv2Round1",
    EddsaMPCv2Round2 = "EddsaMPCv2Round2",
    EddsaMPCv2Round3 = "EddsaMPCv2Round3"
}
export declare enum MPCType {
    EDDSA = "eddsa",
    ECDSA = "ecdsa"
}
export interface CustomPaillierModulusGetterFunction {
    (params: {
        txRequest: TxRequest;
    }): Promise<{
        userPaillierModulus: string;
    }>;
}
export interface CustomKShareGeneratingFunction {
    (params: {
        tssParams: TSSParams | TSSParamsForMessage;
        challenges: {
            enterpriseChallenge: EcdsaTypes.SerializedEcdsaChallenges;
            bitgoChallenge: TxRequestChallengeResponse;
        };
        requestType: RequestType;
    }): Promise<TssEcdsaStep1ReturnMessage>;
}
export interface CustomMuDeltaShareGeneratingFunction {
    (params: {
        txRequest: TxRequest;
        aShareFromBitgo: Omit<AShare, 'ntilde' | 'h1' | 'h2'>;
        bitgoChallenge: TxRequestChallengeResponse;
        encryptedWShare: string;
    }): Promise<TssEcdsaStep2ReturnMessage>;
}
export interface CustomSShareGeneratingFunction {
    (params: {
        tssParams: TSSParams | TSSParamsForMessage;
        dShareFromBitgo: DShare;
        requestType: RequestType;
        encryptedOShare: string;
    }): Promise<SShare>;
}
export interface CustomCommitmentGeneratingFunction {
    (params: {
        txRequest: TxRequest;
        bitgoGpgPubKey?: string;
    }): Promise<{
        userToBitgoCommitment: CommitmentShareRecord;
        encryptedSignerShare: EncryptedSignerShareRecord;
        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
    }>;
}
export interface CustomRShareGeneratingFunction {
    (params: {
        txRequest: TxRequest;
        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
    }): Promise<{
        rShare: SignShare;
    }>;
}
export interface CustomGShareGeneratingFunction {
    (params: {
        txRequest: TxRequest;
        userToBitgoRShare: SignShare;
        bitgoToUserRShare: SignatureShareRecord;
        bitgoToUserCommitment: CommitmentShareRecord;
    }): Promise<GShare>;
}
export interface CustomMPCv2SigningRound1GeneratingFunction {
    (params: {
        txRequest: TxRequest;
    }): Promise<{
        signatureShareRound1: SignatureShareRecord;
        encryptedRound1Session: string;
        userGpgPubKey: string;
        encryptedUserGpgPrvKey: string;
    }>;
}
export interface CustomMPCv2SigningRound2GeneratingFunction {
    (params: {
        txRequest: TxRequest;
        bitgoPublicGpgKey: string;
        encryptedUserGpgPrvKey: string;
        encryptedRound1Session: string;
    }): Promise<{
        signatureShareRound2: SignatureShareRecord;
        encryptedRound2Session: string;
    }>;
}
export interface CustomMPCv2SigningRound3GeneratingFunction {
    (params: {
        txRequest: TxRequest;
        bitgoPublicGpgKey: string;
        encryptedUserGpgPrvKey: string;
        encryptedRound2Session: string;
    }): Promise<{
        signatureShareRound3: SignatureShareRecord;
    }>;
}
export interface CustomEddsaMPCv2SigningRound1GeneratingFunction {
    (params: {
        txRequest: TxRequest;
    }): Promise<{
        signatureShareRound1: SignatureShareRecord;
        encryptedRound1Session: string;
        userGpgPubKey: string;
        encryptedUserGpgPrvKey: string;
    }>;
}
export interface CustomEddsaMPCv2SigningRound2GeneratingFunction {
    (params: {
        txRequest: TxRequest;
        bitgoPublicGpgKey: string;
        encryptedUserGpgPrvKey: string;
        encryptedRound1Session: string;
    }): Promise<{
        signatureShareRound2: SignatureShareRecord;
        encryptedRound2Session: string;
    }>;
}
export interface CustomEddsaMPCv2SigningRound3GeneratingFunction {
    (params: {
        txRequest: TxRequest;
        bitgoPublicGpgKey: string;
        encryptedUserGpgPrvKey: string;
        encryptedRound2Session: string;
    }): Promise<{
        signatureShareRound3: SignatureShareRecord;
    }>;
}
export declare enum TokenType {
    ERC721 = "ERC721",
    ERC1155 = "ERC1155",
    ERC20 = "ERC20",
    DIGITAL_ASSET = "Digital Asset"
}
export interface TokenTransferRecipientParams {
    tokenType: TokenType;
    tokenQuantity: string;
    tokenContractAddress?: string;
    tokenName?: string;
    tokenId?: string;
    decimalPlaces?: number;
}
interface IntentOptionsBase {
    reqId: IRequestTracer;
    intentType: string;
    sequenceId?: string;
    isTss?: boolean;
    comment?: string;
    memo?: Memo;
    custodianTransactionId?: string;
    custodianMessageId?: string;
}
export interface IntentOptionsForMessage extends IntentOptionsBase {
    messageRaw: string;
    messageEncoded?: string;
    messageStandardType?: MessageStandardType;
    signerAddress?: string;
}
export interface IntentOptionsForTypedData extends IntentOptionsBase {
    typedDataRaw: string;
    typedDataEncoded?: string;
}
export interface PrebuildTransactionWithIntentOptions extends IntentOptionsBase {
    recipients?: {
        address: string;
        amount: string | number;
        data?: string;
        tokenName?: string;
        tokenData?: TokenTransferRecipientParams;
    }[];
    tokenName?: string;
    enableTokens?: TokenEnablement[];
    nonce?: string;
    selfSend?: boolean;
    feeOptions?: FeeOption | EIP1559FeeOptions;
    hopParams?: HopParams;
    lowFeeTxid?: string;
    custodianTransactionId?: string;
    receiveAddress?: string;
    unspents?: string[];
    /**
     * MIST to redeem from the sender's address balance (SIP-58 / SUI address balances).
     * When set, the PTB includes tx.withdrawal() + redeem_funds() before the transfer.
     */
    fundsInAddressBalance?: string;
    /**
     * The receive address from which funds will be withdrawn.
     * This feature is supported only for specific coins, like ADA.
     */
    senderAddress?: string;
    /**
     * Custom Solana instructions for use with the customTx intent type.
     * Each instruction should contain programId, keys, and data fields.
     */
    solInstructions?: SolInstruction[];
    /**
     * Deconstructed Versioned Transaction data for Solana customTx intent type.
     * Contains compiled instructions, Address Lookup Tables, and static account keys.
     */
    solVersionedTransactionData?: SolVersionedTransactionData;
    /**
     * Custom transaction parameters for Aptos entry function calls.
     * Used with the customTx intent type for Aptos smart contract interactions.
     */
    aptosCustomTransactionParams?: {
        moduleName: string;
        functionName: string;
        typeArguments?: string[];
        functionArguments?: any[];
        abi?: any;
    };
    txRequestId?: string;
    isTestTransaction?: boolean;
    transferOfferId?: string;
    /**
     * Amount for intents that use a top-level amount instead of recipients (e.g. bridgeFunds).
     */
    amount?: {
        value: string;
        symbol: string;
    };
    /**
     * TIP-20 token address to use for paying transaction fees (Tempo only).
     */
    feeToken?: string;
    /** Canton-specific params for the cantonCommand intent. */
    cantonCommandParams?: CantonCommandParams;
}
export interface IntentRecipient {
    address: {
        address: string;
    };
    amount: {
        value: string | number;
        symbol: string;
    };
    data?: string;
    tokenData?: TokenTransferRecipientParams;
}
interface PopulatedIntentBase {
    intentType: string;
    sequenceId?: string;
    comment?: string;
    memo?: string;
    isTss?: boolean;
}
export interface PopulatedIntentForMessageSigning extends PopulatedIntentBase {
    messageRaw: string;
    messageEncoded: string;
    custodianMessageId?: string;
    messageStandardType?: MessageStandardType;
    signerAddress?: string;
}
export interface PopulatedIntentForTypedDataSigning extends PopulatedIntentBase {
    messageRaw: string;
    messageEncoded: string;
    custodianMessageId?: string;
}
export interface PopulatedIntent extends PopulatedIntentBase {
    recipients?: IntentRecipient[];
    nonce?: string;
    token?: string;
    enableTokens?: TokenEnablement[];
    unspents?: string[];
    fundsInAddressBalance?: string;
    /**
     * The receive address from which funds will be withdrawn.
     * This feature is supported only for specific coins, like ADA.
     */
    senderAddress?: string;
    selfSend?: boolean;
    feeOptions?: FeeOption | EIP1559FeeOptions;
    /**
     * TIP-20 token address to use for paying transaction fees (Tempo only).
     * This is placed at the intent level, not nested in feeOptions.
     */
    feeToken?: string;
    hopParams?: HopParams;
    txid?: string;
    receiveAddress?: string;
    custodianTransactionId?: string;
    custodianMessageId?: string;
    tokenName?: string;
    /**
     * Custom Solana instructions for use with the customTx intent type.
     * Each instruction should contain programId, keys, and data fields.
     */
    solInstructions?: SolInstruction[];
    /**
     * Deconstructed Versioned Transaction data for Solana customTx intent type.
     * Contains compiled instructions, Address Lookup Tables, and static account keys.
     */
    solVersionedTransactionData?: SolVersionedTransactionData;
    /**
     * Custom Aptos transaction for use with the customTx intent type.
     */
    aptosCustomTransactionParams?: aptosCustomTransactionParams;
    txRequestId?: string;
    isTestTransaction?: boolean;
    transferOfferId?: string;
    /**
     * Amount for intents that use a top-level amount instead of recipients (e.g. bridgeFunds).
     */
    amount?: {
        value: string;
        symbol: string;
    };
    /** Canton-specific params serialized into the cantonCommand intent payload. */
    cantonCommandParams?: CantonCommandParams;
}
export type TxRequestState = 'pendingCommitment' | 'pendingApproval' | 'canceled' | 'rejected' | 'initialized' | 'pendingDelivery' | 'delivered' | 'pendingUserSignature' | 'signed';
export type TransactionState = 'initialized' | 'pendingCommitment' | 'pendingSignature' | 'signed' | 'held' | 'delivered' | 'invalidSignature' | 'rejected';
export type SignableTransaction = {
    serializedTxHex: string;
    signableHex: string;
};
export interface ReplayProtectionOptions {
    chain: string | number;
    hardfork: string;
}
export type UnsignedTransactionTss = SignableTransaction & {
    derivationPath: string;
    feeInfo?: {
        fee: number;
        feeString: string;
    };
    coinSpecific?: Record<string, unknown>;
    parsedTx?: unknown;
    eip1559?: EIP1559FeeOptions;
    replayProtectionOptions?: ReplayProtectionOptions;
};
export type UnsignedMessageTss = {
    derivationPath: string;
    message: string;
};
export declare enum RequestType {
    tx = 0,
    message = 1
}
export type SignedTx = {
    id: string;
    tx: string;
    publicKey?: string;
    signature?: string;
};
export type TxRequest = {
    txRequestId: string;
    walletId: string;
    walletType: WalletType;
    version: number;
    enterpriseId?: string;
    state: TxRequestState;
    date: string;
    userId: string;
    intent: unknown;
    pendingApprovalId?: string;
    policiesChecked: boolean;
    signatureShares?: SignatureShareRecord[];
    commitmentShares?: CommitmentShareRecord[];
    pendingTxHashes?: string[];
    txHashes?: string[];
    unsignedMessages?: UnsignedMessageTss[];
    unsignedTxs: UnsignedTransactionTss[];
    transactions?: {
        state: TransactionState;
        unsignedTx: UnsignedTransactionTss;
        signatureShares: SignatureShareRecord[];
        signedTx?: SignedTx;
        commitmentShares?: CommitmentShareRecord[];
    }[];
    messages?: {
        state: TransactionState;
        signatureShares: SignatureShareRecord[];
        messageRaw: string;
        messageEncoded?: string;
        messageBroadcastable?: string;
        messageStandardType?: MessageStandardType;
        derivationPath: string;
        combineSigShare?: string;
        txHash?: string;
        commitmentShares?: CommitmentShareRecord[];
    }[];
    apiVersion?: TxRequestVersion;
    latest: boolean;
};
export type CreateKeychainParamsBase = {
    userGpgKey: SerializedKeyPair<string>;
    bitgoKeychain: Keychain;
    passphrase?: string;
    enterprise?: string;
    originalPasscodeEncryptionCode?: string;
    webauthnInfo?: WebauthnKeyEncryptionInfo;
    encryptionVersion?: EncryptionVersion;
    encryptionSession?: IEncryptionSession;
};
export type CreateBitGoKeychainParamsBase = Omit<CreateKeychainParamsBase, 'bitgoKeychain'>;
/**
 * Checks whether a ciphertext string is a v2 encryption envelope.
 */
export declare function isV2Envelope(ciphertext: string): boolean;
export declare const SignatureShareType: {
    readonly USER: "user";
    readonly BACKUP: "backup";
    readonly BITGO: "bitgo";
};
export type SignatureShareType = (typeof SignatureShareType)[keyof typeof SignatureShareType];
interface ShareBaseRecord {
    from: SignatureShareType;
    to: SignatureShareType;
    share: string;
}
export interface SignatureShareRecord extends ShareBaseRecord {
    vssProof?: string;
    privateShareProof?: string;
    publicShare?: string;
}
export declare const CommitmentType: {
    readonly COMMITMENT: "commitment";
    readonly DECOMMITMENT: "decommitment";
};
export type CommitmentType = (typeof CommitmentType)[keyof typeof CommitmentType];
export interface CommitmentShareRecord extends ShareBaseRecord {
    type: CommitmentType;
}
export interface ExchangeCommitmentResponse {
    commitmentShare: CommitmentShareRecord;
}
export declare const EncryptedSignerShareType: {
    readonly ENCRYPTED_SIGNER_SHARE: "encryptedSignerShare";
    readonly ENCRYPTED_R_SHARE: "encryptedRShare";
};
export type EncryptedSignerShareType = (typeof EncryptedSignerShareType)[keyof typeof EncryptedSignerShareType];
export interface EncryptedSignerShareRecord extends ShareBaseRecord {
    type: EncryptedSignerShareType;
}
export type BitgoPubKeyType = 'nitro' | 'onprem';
export type TSSParams = {
    txRequest: string | TxRequest;
    reqId: IRequestTracer;
    apiVersion?: ApiVersion;
    txParams?: TransactionParams;
};
export type TSSParamsForMessage = TSSParams & {
    messageRaw: string;
    messageEncoded?: string;
    bufferToSign: Buffer;
};
/** At least one recipient (when using `recipientSource: TssTxRecipientSource.Explicit`). */
export type NonEmptyRecipientList = [ITransactionRecipient, ...ITransactionRecipient[]];
/** txParams including a non-empty recipients list for strict signing verification typing. */
export type TransactionParamsWithMandatoryRecipients = TransactionParams & {
    recipients: NonEmptyRecipientList;
};
export declare const TssTxRecipientSource: {
    /** Require txParams.recipients with at least one entry (enforced by TypeScript for this branch). */
    readonly Explicit: "explicit";
    /**
     * Default: txParams may be omitted or partial; verification uses coin-specific rules
     * (for example recipients from txRequest context).
     */
    readonly Resolved: "resolved";
};
export type TssTxRecipientSource = (typeof TssTxRecipientSource)[keyof typeof TssTxRecipientSource];
export type TssSignTxExplicitRecipientParams = {
    txRequest: string | TxRequest;
    reqId: IRequestTracer;
    apiVersion?: ApiVersion;
    recipientSource: typeof TssTxRecipientSource.Explicit;
    txParams: TransactionParamsWithMandatoryRecipients;
};
export type TssSignTxResolvedRecipientParams = {
    txRequest: string | TxRequest;
    reqId: IRequestTracer;
    apiVersion?: ApiVersion;
    recipientSource?: typeof TssTxRecipientSource.Resolved;
    txParams?: TransactionParams;
};
/**
 * Parameters for TSS transaction signing ({@link ITssUtils.signTxRequest}).
 * Set {@link TssTxRecipientSource.Explicit} to require a non-empty txParams.recipients array at compile time.
 */
export type TssSignTxRequestParams = TssSignTxExplicitRecipientParams | TssSignTxResolvedRecipientParams;
export type TssSignTxRequestParamsWithPrv = TssSignTxRequestParams & {
    prv: string;
    mpcv2PartyId?: 0 | 1;
};
/**
 * @deprecated Use {@link TssSignTxRequestParamsWithPrv} instead. This alias exists for
 * backwards compatibility and will be removed in a future major release.
 */
export type TSSParamsWithPrv = TssSignTxRequestParamsWithPrv;
export type TSSParamsForMessageWithPrv = TSSParamsForMessage & {
    prv: string;
    mpcv2PartyId?: 0 | 1;
};
export interface BitgoHeldBackupKeyShare {
    commonKeychain?: string;
    id: string;
    keyShares: ApiKeyShare[];
}
export interface BackupKeyShare {
    bitGoHeldKeyShares?: BitgoHeldBackupKeyShare;
    userHeldKeyShare?: KeyShare;
}
export interface BitgoGPGPublicKey {
    name: string;
    publicKey: string;
    mpcv2PublicKey?: string;
    eddsaMpcv2PublicKey?: string;
    enterpriseId: string;
}
export interface MPCTx {
    serializedTx: string;
    scanIndex?: number;
    coin?: string;
    signableHex?: string;
    derivationPath?: string;
    parsedTx?: ParsedTransaction;
    feeInfo?: {
        fee: number;
        feeString: string;
    };
    coinSpecific?: {
        firstValid?: number;
        maxDuration?: number;
        commonKeychain?: string;
        lastScanIndex?: number;
    };
    recoveryAmount?: string;
    signature?: string;
}
export interface MPCRecoveryOptions {
    userKey?: string;
    backupKey?: string;
    bitgoKey: string;
    recoveryDestination: string;
    walletPassphrase?: string;
    seed?: string;
    index?: number;
    startingScanIndex?: number;
    scan?: number;
    tokenContractAddress?: string;
    apiKey?: string;
}
export interface MPCConsolidationRecoveryOptions {
    userKey?: string;
    backupKey?: string;
    bitgoKey: string;
    walletPassphrase?: string;
    startingScanIndex?: number;
    endingScanIndex?: number;
    seed?: string;
    tokenContractAddress?: string;
}
export interface MPCSweepTxs {
    txRequests: RecoveryTxRequest[];
}
export interface RecoveryTxRequest {
    walletCoin: string;
    transactions: MPCUnsignedTx[] | OvcTransaction[];
}
export interface MPCUnsignedTx {
    unsignedTx: MPCTx;
    signatureShares: [];
}
export interface MPCSweepRecoveryOptions {
    signatureShares: SignatureShares[];
}
interface SignatureShares {
    txRequest: RecoveryTxRequest;
    tssVersion: string;
    ovc: Ovc[];
}
interface OvcTransaction {
    unsignedTx: MPCTx;
    signatureShares: SignatureShareRecord[];
    signatureShare: SignatureShare;
}
interface SignatureShare {
    from: string;
    to: string;
    share: string;
    publicShare: string;
}
interface Ovc {
    eddsaSignature: Signature;
    ecdsaSignature?: EcdsaSignature;
}
export interface MPCTxs {
    transactions: MPCTx[];
    lastScanIndex?: number;
}
export interface OvcInput {
    address: string;
    value: number;
    valueString: string;
}
export interface OvcOutput {
    address: string;
    valueString: string;
    coinName?: string;
}
export type BackupGpgKey = SerializedKeyPair<string> | Key;
/**
 * Common Interface for implementing signature scheme specific
 * util functions
 */
export interface ITssUtils<KeyShare = EDDSA.KeyShare> {
    createBitgoHeldBackupKeyShare(userGpgKey: SerializedKeyPair<string>, enterprise: string | undefined): Promise<BitgoHeldBackupKeyShare>;
    finalizeBitgoHeldBackupKeyShare(keyId: string, commonKeychain: string, userKeyShare: KeyShare, bitgoKeychain: Keychain, gpgKey: SerializedKeyPair<string>, bitgoPublicGpgKey?: Key): Promise<BitgoHeldBackupKeyShare>;
    createUserKeychain(params: CreateKeychainParamsBase): Promise<Keychain>;
    createBackupKeychain(params: CreateKeychainParamsBase): Promise<Keychain>;
    createBitgoKeychain(params: CreateBitGoKeychainParamsBase): Promise<Keychain>;
    createKeychains(params: {
        passphrase: string;
        enterprise?: string;
        originalPasscodeEncryptionCode?: string;
        isThirdPartyBackup?: boolean;
        encryptionVersion?: EncryptionVersion;
    }): Promise<KeychainsTriplet>;
    signTxRequest(params: TssSignTxRequestParamsWithPrv): Promise<TxRequest>;
    signTxRequestForMessage(params: TSSParams): Promise<TxRequest>;
    signEddsaTssUsingExternalSigner(txRequest: string | TxRequest, externalSignerCommitmentGenerator: CustomCommitmentGeneratingFunction, externalSignerRShareGenerator: CustomRShareGeneratingFunction, externalSignerGShareGenerator: CustomGShareGeneratingFunction): Promise<TxRequest>;
    signEcdsaTssUsingExternalSigner(params: TSSParams | TSSParamsForMessage, requestType: RequestType, externalSignerPaillierModulusGetter: CustomPaillierModulusGetterFunction, externalSignerKShareGenerator: CustomKShareGeneratingFunction, externalSignerMuDeltaShareGenerator: CustomMuDeltaShareGeneratingFunction, externalSignerSShareGenerator: CustomSShareGeneratingFunction): Promise<TxRequest>;
    createCommitmentShareFromTxRequest(params: {
        txRequest: TxRequest;
        prv: string;
        walletPassphrase: string;
        bitgoGpgPubKey: string;
    }): Promise<{
        userToBitgoCommitment: CommitmentShareRecord;
        encryptedSignerShare: EncryptedSignerShareRecord;
        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
    }>;
    createRShareFromTxRequest(params: {
        txRequest: TxRequest;
        walletPassphrase: string;
        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
    }): Promise<{
        rShare: SignShare;
    }>;
    createGShareFromTxRequest(params: {
        txRequest: TxRequest;
        prv: string;
        bitgoToUserRShare: SignatureShareRecord;
        userToBitgoRShare: SignShare;
        bitgoToUserCommitment: CommitmentShareRecord;
    }): Promise<GShare>;
    prebuildTxWithIntent(params: PrebuildTransactionWithIntentOptions, apiVersion?: TxRequestVersion, preview?: boolean): Promise<TxRequest>;
    deleteSignatureShares(txRequestId: string): Promise<SignatureShareRecord[]>;
    sendTxRequest(txRequestId: string): Promise<any>;
    recreateTxRequest(txRequestId: string, decryptedPrv: string, reqId: IRequestTracer): Promise<TxRequest>;
    getTxRequest(txRequestId: string): Promise<TxRequest>;
    supportedTxRequestVersions(): TxRequestVersion[];
}
export {};
//# sourceMappingURL=baseTypes.d.ts.map