import { DelegateeDetails, DelegatorDetails } from '@airgap/coinlib-core';
import { DelegationDetails } from '@airgap/coinlib-core/protocols/ICoinDelegateProtocol';
import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolMetadata, PublicKey, SecretKey, Signature, TransactionFullConfiguration, TransactionDetails } from '@airgap/module-kit';
import { AirGapDelegateProtocol } from '@airgap/module-kit/internal';
import { CosmosCryptoConfiguration } from '../types/crypto';
import { CosmosTransaction } from '../types/data/transaction/CosmosTransaction';
import { CosmosProtocolNetwork, CosmosProtocolOptions } from '../types/protocol';
import { CosmosDelegation, CosmosUnbondingDelegation, CosmosValidator } from '../types/rpc';
import { CosmosDelegationActionType, CosmosSignedTransaction, CosmosTransactionCursor, CosmosUnsignedTransaction } from '../types/transaction';
export interface CosmosBaseProtocol<_Units extends string> extends AirGapProtocol<{
    AddressResult: Address;
    ProtocolNetwork: CosmosProtocolNetwork;
    CryptoConfiguration: CosmosCryptoConfiguration;
    SignedTransaction: CosmosSignedTransaction;
    TransactionCursor: CosmosTransactionCursor;
    Units: _Units;
    FeeEstimation: FeeDefaults<_Units>;
    UnsignedTransaction: CosmosUnsignedTransaction;
}, 'Crypto', 'FetchDataForAddress'> {
    getKeyPairFromSecretKey(secretKey: SecretKey): Promise<KeyPair>;
}
export interface CosmosBaseStakingProtocol<_Units extends string> extends CosmosBaseProtocol<_Units>, AirGapDelegateProtocol {
    prepareDelegatorActionFromPublicKey(publicKey: PublicKey, type: CosmosDelegationActionType, data?: {
        validator: Address;
        amount?: string;
    }): Promise<CosmosTransaction[]>;
    undelegate(publicKey: PublicKey, validatorAddress: Address, amount: Amount<_Units>, memo?: string): Promise<CosmosTransaction>;
    delegate(publicKey: PublicKey, validatorAddress: Address | string[], amount: Amount<_Units>, undelegate: boolean, memo?: string): Promise<CosmosTransaction>;
    withdrawDelegationRewards(publicKey: PublicKey, validatorAddresses: Address[], memo?: string): Promise<CosmosTransaction>;
    withdrawAllDelegationRewards(delegatorAddress: Address, fee: Amount<_Units>, memo?: string): Promise<string>;
    fetchTotalReward(delegatorAddress: Address): Promise<Amount<_Units>>;
    fetchRewardForDelegation(delegatorAddress: Address, validatorAddress: Address): Promise<Amount<_Units>>;
    fetchDelegations(address: Address): Promise<CosmosDelegation[]>;
    fetchTotalDelegatedAmount(address: Address): Promise<Amount<_Units>>;
    fetchValidator(address: Address): Promise<CosmosValidator>;
    fetchValidators(): Promise<CosmosValidator[]>;
    fetchUnbondingDelegations(delegatorAddress: Address): Promise<CosmosUnbondingDelegation[]>;
    fetchTotalUnbondingAmount(address: Address): Promise<Amount<_Units>>;
    fetchSelfDelegation(address: Address): Promise<CosmosDelegation>;
}
export declare abstract class CosmosBaseProtocolImpl<_Units extends string> implements CosmosBaseStakingProtocol<_Units> {
    protected readonly options: CosmosProtocolOptions<_Units>;
    private readonly nodeClient;
    private readonly cryptoClient;
    private readonly cryptoConfiguration;
    constructor(options: CosmosProtocolOptions<_Units>);
    getKeyPairFromSecretKey(secretKey: SecretKey): Promise<KeyPair>;
    getCryptoConfiguration(): Promise<CosmosCryptoConfiguration>;
    getKeyPairFromDerivative(derivative: CryptoDerivative): Promise<KeyPair>;
    signTransactionWithSecretKey(transaction: CosmosUnsignedTransaction, secretKey: SecretKey): Promise<CosmosSignedTransaction>;
    abstract getMetadata(): Promise<ProtocolMetadata<_Units, _Units>>;
    getAddressFromPublicKey(publicKey: PublicKey): Promise<string>;
    getDetailsFromTransaction(transaction: CosmosSignedTransaction | CosmosUnsignedTransaction, publicKey: PublicKey): Promise<AirGapTransaction<_Units, _Units>[]>;
    private getDetailsFromSignedTransaction;
    private getDetailsFromUnsignedTransaction;
    getNetwork(): Promise<CosmosProtocolNetwork>;
    getTransactionsForPublicKey(publicKey: PublicKey, limit: number, cursor?: CosmosTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<CosmosTransactionCursor, _Units, _Units>>;
    getBalanceOfPublicKey(publicKey: PublicKey, configuration?: undefined): Promise<Balance<_Units>>;
    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: string[], configuration?: TransactionFullConfiguration<_Units> | undefined): Promise<Amount<_Units>>;
    abstract getTransactionFeeWithPublicKey(publicKey: PublicKey, details: TransactionDetails<_Units>[]): Promise<FeeDefaults<_Units>>;
    prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<_Units>[], configuration?: TransactionFullConfiguration<_Units> | undefined): Promise<CosmosUnsignedTransaction>;
    broadcastTransaction(transaction: CosmosSignedTransaction): Promise<string>;
    signMessageWithKeyPair(message: string, keyPair: KeyPair): Promise<Signature>;
    verifyMessageWithPublicKey(message: string, signature: Signature, publicKey: PublicKey): Promise<boolean>;
    decryptAsymmetricWithKeyPair(payload: string, keyPair: KeyPair): Promise<string>;
    encryptAsymmetricWithPublicKey(payload: string, publicKey: PublicKey): Promise<string>;
    encryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
    decryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
    getTransactionsForAddress(address: string, limit: number, cursor?: CosmosTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<CosmosTransactionCursor, _Units, _Units>>;
    getBalanceOfAddress(address: string, _configuration?: undefined): Promise<Balance<_Units>>;
    getDefaultDelegatee(): Promise<string>;
    getCurrentDelegateesForPublicKey(publicKey: PublicKey): Promise<string[]>;
    getCurrentDelegateesForAddress(address: string): Promise<string[]>;
    getDelegateeDetails(address: string): Promise<DelegateeDetails>;
    isPublicKeyDelegating(publicKey: PublicKey): Promise<boolean>;
    isAddressDelegating(address: string): Promise<boolean>;
    getDelegatorDetailsFromPublicKey(publicKey: PublicKey): Promise<DelegatorDetails>;
    getDelegatorDetailsFromAddress(address: string): Promise<DelegatorDetails>;
    private getDelegatorDetails;
    private getAvailableDelegatorActions;
    getDelegationDetailsFromPublicKey(publicKey: PublicKey, delegatees: string[]): Promise<DelegationDetails>;
    getDelegationDetailsFromAddress(address: string, delegatees: string[]): Promise<DelegationDetails>;
    prepareDelegatorActionFromPublicKey(publicKey: PublicKey, type: CosmosDelegationActionType, data?: {
        validator: string;
        amount?: string;
    } | undefined): Promise<CosmosTransaction[]>;
    undelegate(publicKey: PublicKey, validatorAddress: string, amount: Amount<_Units>, memo?: string | undefined): Promise<CosmosTransaction>;
    delegate(publicKey: PublicKey, validatorAddress: string | string[], amount: Amount<_Units>, undelegate: boolean, memo?: string | undefined): Promise<CosmosTransaction>;
    withdrawDelegationRewards(publicKey: PublicKey, _validatorAddresses: string[], memo?: string | undefined): Promise<CosmosTransaction>;
    withdrawAllDelegationRewards(delegatorAddress: string, fee: Amount<_Units>, memo?: string | undefined): Promise<string>;
    fetchTotalReward(delegatorAddress: string): Promise<Amount<_Units>>;
    fetchRewardForDelegation(delegatorAddress: string, validatorAddress: string): Promise<Amount<_Units>>;
    fetchDelegations(address: string): Promise<CosmosDelegation[]>;
    fetchTotalDelegatedAmount(address: string): Promise<Amount<_Units>>;
    fetchValidator(address: string): Promise<CosmosValidator>;
    fetchValidators(): Promise<CosmosValidator[]>;
    fetchUnbondingDelegations(delegatorAddress: string): Promise<CosmosUnbondingDelegation[]>;
    fetchTotalUnbondingAmount(address: string): Promise<Amount<_Units>>;
    fetchSelfDelegation(address: string): Promise<CosmosDelegation>;
}