import BigNumber from '@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
import { Cache } from '@airgap/coinlib-core/utils/cache';
import { TypedSubstrateAddress } from '../data/account/address/SubstrateAddressFactory';
import { SubstrateAccountInfo } from '../data/account/SubstrateAccountInfo';
import { SubstrateCall } from '../data/metadata/decorator/call/SubstrateCall';
import { MetadataDecorator } from '../data/metadata/decorator/MetadataDecorator';
import { SCALEType } from '../data/scale/type/SCALEType';
import { SubstrateRuntimeVersion } from '../data/state/SubstrateRuntimeVersion';
import { SubstrateTransactionType } from '../data/transaction/SubstrateTransaction';
import { SubstrateProtocolConfiguration, SubstrateRpcConfiguration } from '../types/configuration';
import { SubstrateNodeClient } from './SubstrateNodeClient';
interface ConnectionConfig {
    allowCache: boolean;
}
export declare class SubstrateCommonNodeClient<C extends SubstrateProtocolConfiguration> implements SubstrateNodeClient<C> {
    protected readonly configuration: C;
    protected readonly url: string;
    protected metadata: MetadataDecorator | undefined;
    protected runtimeVersion: number | undefined;
    protected readonly lastFees: Map<SubstrateTransactionType<C>, BigNumber>;
    protected initApiPromise: Promise<void> | null;
    protected readonly storageEntries: Record<string, string[]>;
    protected readonly calls: Record<string, string[]>;
    protected readonly constants: Record<string, string[]>;
    protected readonly callEndpoints: SubstrateCallEndpoints<C>;
    protected readonly cache: Cache;
    constructor(configuration: C, url: string);
    getAccountInfo(address: TypedSubstrateAddress<C>): Promise<SubstrateAccountInfo | undefined>;
    getExistentialDeposit(): Promise<BigNumber | undefined>;
    getBlockTime(): Promise<BigNumber>;
    getFirstBlockHash(): Promise<string | undefined>;
    getLastBlockHash(): Promise<string | undefined>;
    protected getBlockHash(blockNumber?: number): Promise<string | undefined>;
    getCurrentHeight(): Promise<BigNumber>;
    getRuntimeVersion(): Promise<SubstrateRuntimeVersion | undefined>;
    getTransferFeeEstimate(transaction: string | Uint8Array): Promise<BigNumber | undefined>;
    saveLastFee(type: SubstrateTransactionType<C>, fee: BigNumber): void;
    getSavedLastFee(type: SubstrateTransactionType<C>, defaultValue: 'undefined' | 'largest'): BigNumber | undefined;
    getTransactionMetadata(type: SubstrateTransactionType<C>): Promise<SubstrateCall>;
    submitTransaction(encoded: string): Promise<string>;
    protected fromStorage<Module extends SubstrateStorageModuleName<C>, Entry extends SubstrateStorageEntryName<C, Module>>(moduleName: Module, entryName: Entry, ...args: SCALEType[]): Promise<string | null>;
    protected getCall<Module extends SubstrateCallModuleName<C>, Call extends SubstrateCallName<C, Module>>(moduleName: Module, callName: Call): Promise<SubstrateCall>;
    protected getConstant<Module extends SubstrateConstantModuleName<C>, Constant extends SubstrateConstantName<C, Module>>(moduleName: Module, constantName: Constant): Promise<string>;
    protected initApi(): Promise<void>;
    protected initCache(): Promise<void>;
    protected send<T extends SubstrateRpcModuleName<C>, S extends SubstrateRpcMethodName<C, T>>(module: T, method: S, params?: string[], config?: ConnectionConfig): Promise<any>;
    private sendRepeat;
    protected registerCallEntrypointEntries(entries: [SubstrateTransactionType<C>, [SubstrateCallModuleName<C>, SubstrateCallName<C, any>]][]): void;
    protected createCallEndpointEntry<Module extends SubstrateCallModuleName<C>, Call extends SubstrateCallName<C, Module>>(transactionType: SubstrateTransactionType<C>, moduleName: Module, callName: Call): [SubstrateTransactionType<C>, [SubstrateCallModuleName<C>, SubstrateCallName<C, any>]];
    protected mergeSupportedCalls(configured: Record<string, Readonly<string[]>>, common: Record<string, Readonly<string[]>>): Record<string, string[]>;
}
declare const commonRpcMethods: {
    author: readonly ["submitExtrinsic"];
    chain: readonly ["getBlock", "getBlockHash"];
    state: readonly ["getMetadata", "getStorage", "getRuntimeVersion"];
    payment: readonly ["queryInfo"];
};
export declare type SubstrateRpcModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'methods', typeof commonRpcMethods>;
export declare type SubstrateRpcMethodName<C extends SubstrateProtocolConfiguration, T extends SubstrateRpcModuleName<C>> = ModuleEntry<C, 'methods', typeof commonRpcMethods, T>;
declare const commonStorageEntries: {
    System: readonly ["Account"];
};
declare type SubstrateStorageModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'storageEntries', typeof commonStorageEntries>;
declare type SubstrateStorageEntryName<C extends SubstrateProtocolConfiguration, T extends SubstrateStorageModuleName<C>> = ModuleEntry<C, 'storageEntries', typeof commonStorageEntries, T>;
declare const commonCalls: {
    Balances: readonly ["transfer_allow_death"];
};
declare type SubstrateCallModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'calls', typeof commonCalls>;
declare type SubstrateCallName<C extends SubstrateProtocolConfiguration, T extends SubstrateCallModuleName<C>> = ModuleEntry<C, 'calls', typeof commonCalls, T>;
declare const commonConstants: {
    Balances: readonly ["ExistentialDeposit"];
};
declare type SubstrateConstantModuleName<C extends SubstrateProtocolConfiguration> = ModuleName<C, 'constants', typeof commonConstants>;
declare type SubstrateConstantName<C extends SubstrateProtocolConfiguration, T extends SubstrateConstantModuleName<C>> = ModuleEntry<C, 'constants', typeof commonConstants, T>;
declare type SubstrateCallEndpoints<C extends SubstrateProtocolConfiguration> = Map<SubstrateTransactionType<C>, [
    SubstrateCallModuleName<C>,
    SubstrateCallName<C, any>
]>;
declare type ModuleName<C extends SubstrateProtocolConfiguration, Type extends keyof SubstrateRpcConfiguration, Defaults extends Object> = keyof Defaults | (C['rpc'] extends Object ? (keyof C['rpc'][Type] extends string ? keyof C['rpc'][Type] : never) : never);
declare type ModuleEntry<C extends SubstrateProtocolConfiguration, Type extends keyof SubstrateRpcConfiguration, Defaults extends Record<string, Readonly<string[]>>, T extends ModuleName<C, Type, Defaults>> = ReadonlyEntries<T, Defaults> | (C['rpc'] extends Object ? ReadonlyEntries<T, C['rpc'][Type]> : never);
declare type ReadonlyEntries<T, C> = T extends keyof C ? {
    [S in T]: C[S] extends Readonly<string[]> ? C[S][number] : never;
}[T] : never;
export {};