import { ChainId, ProviderConfig, RetryProvider } from "../network";
import { ChannelRegistry, ModuleConfig } from "../internal";
import { ClearingHouse, ClearingHouseConfig } from "./clearingHouse";
import { ContractReader } from "./contractReader";
import { Contracts } from "../contracts";
import { Liquidities } from "./liquidity";
import { Markets } from "./market";
import { Metadata } from "../metadata";
import { Positions } from "./position";
import { Signer } from "ethers";
import { Vault } from "./vault";
import { Wallet } from "./wallet";
import { DelegateApproval, DelegateApprovalConfigs } from "./clearingHouse/DelegateApproval";
import { LimitOrderBook } from "./limitOrder";
interface ModuleConfigs {
    vault?: ModuleConfig;
    clearingHouse?: ModuleConfig;
    wallet?: ModuleConfig;
    market?: ModuleConfig;
    orders?: ModuleConfig;
    positions?: ModuleConfig;
    delegateApproval?: DelegateApprovalConfigs;
}
interface PerpetualProtocolConfig {
    chainId: ChainId;
    providerConfigs: ProviderConfig[];
    moduleConfigs?: ModuleConfigs;
}
export interface PerpetualProtocolInitialized extends PerpetualProtocol {
    markets: Markets;
    clearingHouse: ClearingHouse;
}
export interface PerpetualProtocolConnected extends PerpetualProtocolInitialized {
    wallet: Wallet;
    positions: Positions;
    liquidities: Liquidities;
    vault: Vault;
    delegateApproval: DelegateApproval;
    limitOrderBook: LimitOrderBook;
}
/**
 * @date 28/12/2021
 * @class PerpetualProtocol
 * @member {ModuleConfigs} moduleConfigs (the default config value will be assigned in the each module)
 */
declare class PerpetualProtocol {
    readonly providerConfigs: ProviderConfig[];
    readonly moduleConfigs?: ModuleConfigs;
    readonly provider: RetryProvider;
    private _metadata?;
    private _contracts?;
    private _contractReader?;
    private readonly _chainId;
    private _channelRegistry;
    private _markets?;
    private _wallet?;
    private _vault?;
    private _clearingHouseConfig?;
    private _clearingHouse?;
    private _positions?;
    private _liquidities?;
    private _delegateApproval?;
    private _limitOrderBook?;
    get metadata(): Metadata;
    get contracts(): Contracts;
    get contractReader(): ContractReader;
    get wallet(): Wallet | undefined;
    get vault(): Vault | undefined;
    get markets(): Markets;
    get clearingHouseConfig(): ClearingHouseConfig;
    get clearingHouse(): ClearingHouse | undefined;
    get positions(): Positions | undefined;
    get liquidities(): Liquidities | undefined;
    get channelRegistry(): ChannelRegistry<string>;
    get delegateApproval(): DelegateApproval | undefined;
    get limitOrderBook(): LimitOrderBook | undefined;
    constructor({ chainId, providerConfigs, moduleConfigs }: PerpetualProtocolConfig);
    init(): Promise<void>;
    connect({ signer }: {
        signer: Signer;
    }): Promise<void>;
    hasInitialized(): this is PerpetualProtocolInitialized;
    hasConnected(): this is PerpetualProtocolConnected;
    destroy(): void;
}
export { PerpetualProtocol };