import { ContractMethodObject, Estimate, TezosToolkit, Wallet } from '@taquito/taquito';
export declare const tzktApiMap: {
    mainnet: string;
    ghostnet: string;
};
export declare const saplingStateMapContract: {
    mainnet: string;
    ghostnet: string;
};
type OrderedTransactionList = [
    ContractMethodObject<Wallet>[],
    ContractMethodObject<Wallet>[],
    {
        txns: (string | void)[];
        contract?: string;
        token_id?: number;
        amount?: number | string;
    }[],
    ContractMethodObject<Wallet>[]
];
interface SaplingDeposits {
    amount: number | string;
    saplingTransactions: (string | void)[];
    owner?: string;
    contract?: string;
    tokenId?: number;
}
interface SaplingTransactions {
    saplingTransactions: (string | void)[];
    contract?: string;
    tokenId?: number;
}
interface ShieldParams {
    amount: number;
    shieldedAddress?: string;
    contract?: string;
    tokenId?: number;
    memo?: string;
}
interface UnshieldParams {
    amount: number;
    unshieldedAddress?: string;
    contract?: string;
    tokenId?: number;
}
interface TransferParams {
    contract?: string;
    tokenId?: number;
    transfers: {
        amount: number;
        to: string;
        memo?: string;
    }[];
}
interface SaplingTokenInfo {
    saplingId?: number;
    contract?: string;
    tokenId?: number;
}
type ShieldBridgeSDKConfig = {
    client: TezosToolkit;
    tzktApi?: 'mainnet' | 'ghostnet';
    minConfirmations?: number;
    saplingStateMapContract?: string;
    gasLimitBuffer?: number;
    storageLimitBuffer?: number;
    useBaseUnits?: boolean;
    parallelThreads?: boolean;
} & ({
    saplingSecret: string;
    saplingMnemonic?: never;
} | {
    saplingSecret?: never;
    saplingMnemonic: string;
});
/**
 * ShieldBridgeSDK provides an abstraction to interact with the Shield Bridge smart contract
 * to shield, unshield, and transfer sapling tokens.
 * @class
 * @param {ShieldBridgeSDKConfig} config The configuration object for the Shield Bridge SDK
 * @param {TezosToolkit} config.client The TezosToolkit instance
 * @param {'mainnet' | 'ghostnet'} [config.tzktApi='mainnet'] The tzkt API to use
 * @param {number} [config.minConfirmations=1] The minimum number of confirmations for the transaction
 * @param {string} [config.saplingStateMapContract='KT1WorWEWjfQqQ1X2BFQiCc4hE3DuDKQVH4U'] The sapling state map contract address
 * @param {number} [config.gasLimitBuffer=2_000] The buffer to add to the estimated gas limit
 * @param {number} [config.storageLimitBuffer=500] The buffer to add to the estimated storage limit
 * @param {boolean} [config.useBaseUnits=false] Whether to use base unit for the token amounts (mutez or token units with decimals)
 * @param {number} [config.parallelThreads=false] Whether to spawn parallel threads for the sapling worker
 * @param {string} [config.saplingSecret] The sapling secret key
 * @param {string} [config.saplingMnemonic] The sapling mnemonic
 * @returns {ShieldBridgeSDK} The Shield Bridge SDK instance
 * @example
 * const tezos = new TezosToolkit('https://mainnet.api.tez.ie');
 * const signerProvider = await InMemorySigner.fromSecretKey('edsk...');
 * tezos.setSignerProvider(signerProvider);
 * const shieldBridge = new ShieldBridgeSDK({
 *  client: tezos,
 *  saplingSecret: 'sask...'
 * });
 * await shieldBridge.shield([
 *   {
 *     amount: 1,
 *     contract: 'KT1...',
 *     tokenId: 0,
 *     memo: 'abcdefgh'
 *   }
 * ]);
 */
export declare class ShieldBridgeSDK {
    private config;
    private tezosClient;
    private saplingWorker;
    saplingStateMapContract: string;
    minConfirmations: number;
    gasLimitBuffer: number;
    storageLimitBuffer: number;
    useBaseUnits: boolean;
    parallelThreads: boolean;
    ready: Promise<boolean>;
    constructor(config: ShieldBridgeSDKConfig);
    initializeSaplingWorker: () => Promise<boolean>;
    /**
     * @description Get the sapling id for the token contract and token id if provided
     * @param {string} [contract] The token contract address
     * @param {number} [tokenId] The token id
     * @returns The sapling id for the token contract and token id if provided
     */
    getSaplingId: (contract?: string, tokenId?: number) => Promise<number | undefined>;
    /**
     * @description Get the metadata for the token contract and token id if provided
     * @param {string} contract The token contract address
     * @param {number} [tokenId] The token id
     * @returns The metadata for the token contract and token id if provided
     */
    getTokenMetadata: (contract: string, tokenId?: number) => Promise<import("@tzkt/sdk-api").Token>;
    /**
     * @description Get the number of decimals for the token contract and token id if provided
     * @param {string} contract The token contract address
     * @param {number} [tokenId] The token id
     * @returns The number of decimals for the token contract and token id if provided
     */
    getTokenDecimals: (contract: string, tokenId?: number) => Promise<number>;
    /**
     * @description Estimate the gas and storage limits for the transaction list of shielding transactions
     * @param {OrderedTransactionList} transactionList The constructed transaction list
     * @returns The estimated gas and storage limits for the transaction list
     */
    estimateShieldTransactionLimits: (transactionList: OrderedTransactionList) => Promise<Estimate[]>;
    /**
     * @description Get the estimated fee for the transaction
     * @param {Estimate} estimate The estimate object
     * @returns The estimated fee for the transaction
     */
    getEstimatedFee: (estimate: Estimate) => number;
    /**
     * @description Submit sapling deposits/shielding transactions
     * @param {SaplingDeposits} saplingDeposits Sapling deposits/shielding transactions to be submitted
     * @param {number} saplingDeposits.amount The amount to be shielded
     * @param {string[]} saplingDeposits.saplingTransactions The sapling transactions to be submitted
     * @param {string} [saplingDeposits.contract] The token contract address
     * @param {number} [saplingDeposits.tokenId] The token id
     * @param {string} [saplingDeposits.owner] The shielded address to apply the shielded tokens
     * @returns The confirmation of the submitted sapling deposits/shielding transactions
     */
    submitSaplingShieldTransaction: (saplingDeposits: SaplingDeposits[]) => Promise<{
        block: import("@taquito/rpc").BlockResponse;
        expectedConfirmation: number;
        currentConfirmation: number;
        completed: boolean;
        isInCurrentBranch: () => Promise<boolean>;
    } | undefined>;
    /**
     * @description Submit sapling withdrawals/unshielding transactions
     * @param {SaplingTransactions} saplingWithdrawals Sapling withdrawals/unshielding transactions to be submitted
     * @param {string[]} saplingWithdrawals.saplingTransactions The sapling transactions to be submitted
     * @param {string} [saplingWithdrawals.contract] The token contract address
     * @param {number} [saplingWithdrawals.tokenId] The token id
     * @returns The confirmation of the submitted sapling withdrawals/unshielding transactions
     */
    submitSaplingUnshieldTransaction: (saplingWithdrawals: SaplingTransactions[]) => Promise<{
        block: import("@taquito/rpc").BlockResponse;
        expectedConfirmation: number;
        currentConfirmation: number;
        completed: boolean;
        isInCurrentBranch: () => Promise<boolean>;
    } | undefined>;
    /**
     * @description Submit sapling transfers transactions
     * @param {SaplingTransactions} saplingTransfers Sapling transfers to be submitted
     * @param {string[]} saplingTransfers.saplingTransactions The sapling transactions to be submitted
     * @param {string} [saplingTransfers.contract] The token contract address
     * @param {number} [saplingTransfers.tokenId] The token id
     * @returns The confirmation of the submitted sapling transfers
     */
    submitSaplingTransferTransaction: (saplingTransfers: SaplingTransactions[]) => Promise<{
        block: import("@taquito/rpc").BlockResponse;
        expectedConfirmation: number;
        currentConfirmation: number;
        completed: boolean;
        isInCurrentBranch: () => Promise<boolean>;
    } | undefined>;
    /**
     * @description Construct the sapling parameters for the shielded transaction
     * @param shieldParam The sapling shielding parameters
     * @param {number} shieldParam.amount The amount to be shielded
     * @param {string} [shieldParam.shieldedAddress] The shielded address to apply the shielded tokens
     * @param {string} [shieldParam.contract] The token contract address
     * @param {number} [shieldParam.tokenId] The token id
     * @param {string} [shieldParam.memo] The memo to be included in the sapling transaction
     * @returns The sapling parameters for the shielded transaction
     */
    constructShieldTokenParams: (shieldParam: ShieldParams) => Promise<{
        saplingTransactions: (string | void)[];
        owner: string;
        amount: string | number;
        contract: string | undefined;
        tokenId: number | undefined;
    }>;
    /**
     * @description Shield the specified amount of unshielded tokens to the sapling address
     * @param {ShieldParams} shieldParams Sapling shielding parameters to be constructed into sapling transactions
     * @param {number} shieldParams.amount The amount to be shielded
     * @param {string} [shieldParams.shieldedAddress] The shielded address to apply the shielded tokens
     * @param {string} [shieldParams.contract] The token contract address
     * @param {number} [shieldParams.tokenId] The token id
     * @param {string} [shieldParams.memo] The memo to be included in the sapling transaction
     * @returns The confirmation of the submitted sapling shielding transactions
     */
    shield: (shieldParams: ShieldParams[]) => Promise<{
        block: import("@taquito/rpc").BlockResponse;
        expectedConfirmation: number;
        currentConfirmation: number;
        completed: boolean;
        isInCurrentBranch: () => Promise<boolean>;
    } | undefined>;
    /**
     * @description Construct the sapling parameters for the unshielded transaction
     * @param unshieldParam The sapling unshielding parameters
     * @param {number} unshieldParam.amount The amount to be unshielded
     * @param {string} [unshieldParam.unshieldedAddress] The unshielded address to apply the unshielded tokens
     * @param {string} [unshieldParam.contract] The token contract address
     * @param {number} [unshieldParam.tokenId] The token id
     * @returns The sapling parameters for the unshielded transaction
     */
    constructUnshieldTokenParams: (unshieldParam: UnshieldParams) => Promise<{
        saplingTransactions: (string | void)[];
        contract: string | undefined;
        tokenId: number | undefined;
    }>;
    /**
     * @description Unshield the specified amount of shielded tokens from the sapling address
     * @param {UnshieldParams} unshieldParams Sapling unshielding parameters to be constructed into sapling transactions
     * @param {number} unshieldParams.amount The amount to be unshielded
     * @param {string} [unshieldParams.unshieldedAddress] The unshielded address to apply the unshielded tokens
     * @param {string} [unshieldParams.contract] The token contract address
     * @param {number} [unshieldParams.tokenId] The token id
     * @returns The confirmation of the submitted sapling unshielding transactions
     */
    unshield: (unshieldParams: UnshieldParams[]) => Promise<{
        block: import("@taquito/rpc").BlockResponse;
        expectedConfirmation: number;
        currentConfirmation: number;
        completed: boolean;
        isInCurrentBranch: () => Promise<boolean>;
    } | undefined>;
    /**
     * @description Construct the sapling parameters for the transfer transaction
     * @param transferParam The sapling transfer parameters
     * @param {string} [transferParam.contract] The token contract address
     * @param {number} [transferParam.tokenId] The token id
     * @param {object} transferParam.transfers The transfers to be made
     * @returns The sapling parameters for the transfer transaction
     */
    constructTransferTokenParams: (transferParam: TransferParams) => Promise<{
        saplingTransactions: (string | void)[];
        contract: string | undefined;
        tokenId: number | undefined;
    }>;
    /**
     * @description Transfer the specified amount of shielded tokens to the specified shielded address
     * @param {TransferParams[]} transferParams Sapling transfer parameters to be constructed into sapling transactions
     * @param {string} [transferParams.contract] The token contract address
     * @param {number} [transferParams.tokenId] The token id
     * @param {object} transferParams.transfers The transfers to be made
     * @returns The confirmation of the submitted sapling transfer transactions
     */
    transfer: (transferParams: TransferParams[]) => Promise<{
        block: import("@taquito/rpc").BlockResponse;
        expectedConfirmation: number;
        currentConfirmation: number;
        completed: boolean;
        isInCurrentBranch: () => Promise<boolean>;
    } | undefined>;
    /**
     * @description Get the shielded sapling token balance for the currently loaded shielded address
     * @param {SaplingTokenInfo} saplingTokenInfo The sapling token information
     * @param {number} [saplingTokenInfo.saplingId] The sapling id
     * @param {string} [saplingTokenInfo.contract] The token contract address
     * @param {number} [saplingTokenInfo.tokenId] The token id
     * @returns The shielded sapling token balance for the currently loaded shielded address
     */
    getShieldedBalance: ({ saplingId, contract, tokenId, }: SaplingTokenInfo) => Promise<number>;
    /**
     * @description Get all the shielded sapling tokens
     * @param includeMetadata Include the metadata for the shielded sapling tokens
     * @returns The shielded sapling tokens
     */
    getAllShieldedAssets: (includeMetadata?: boolean) => Promise<{
        saplingId: number;
        contract?: string;
        tokenId?: number;
        metadata?: any;
    }[]>;
    /**
     * @description Get the shielded sapling token balances for all the sapling tokens
     * @returns The shielded sapling token balances for all the sapling tokens
     */
    getAllShieldedBalances: () => Promise<{
        saplingId: number;
        contract?: string;
        tokenId?: number;
        balance: number;
    }[]>;
    /**
     * @description Get the shielded incoming and outgoing transactions for the specified sapling contract and token id
     * @param {string} [contract] Sapling contract address
     * @param {number} [tokenId] Token id
     * @returns The shielded incoming and outgoing transactions for the specified sapling contract and token id
     */
    getShieldedTransactions: (contract?: string, tokenId?: number) => Promise<{
        incoming: any[];
        outgoing: any[];
    }>;
    /**
     * @description Get the sapling payment address of the currently loaded sapling key
     * @returns The sapling payment address
     */
    getShieldedAddress: () => Promise<string>;
    /**
     * @description Initialize the sapling pool for the specified token contract and token id
     * @param {string} contract The token contract address
     * @param {number} [tokenId] The token id
     * @returns The confirmation of the initialized sapling pool
     */
    initTokenSaplingPool: (contract: string, tokenId?: number) => Promise<{
        block: import("@taquito/rpc").BlockResponse;
        expectedConfirmation: number;
        currentConfirmation: number;
        completed: boolean;
        isInCurrentBranch: () => Promise<boolean>;
    } | undefined>;
}
export {};