import type { IConnector, IWalletConnector } from "./connectors";
import { IDL } from "@dfinity/candid";
import { ActorSubclass, Agent } from "@dfinity/agent";
import { Principal } from "@dfinity/principal";
import { BalanceError, ConnectError, CreateActorError, DisconnectError, InitError, TransferError } from "./connectors";
declare type Plug = {
    createActor: <T>(args: {
        canisterId: string;
        interfaceFactory: IDL.InterfaceFactory;
    }) => Promise<ActorSubclass<T>>;
    agent: Agent;
    createAgent: (options: {
        host: string;
        whitelist: Array<string>;
    }) => Promise<Agent>;
    getPrincipal: () => Promise<Principal>;
    isConnected: () => Promise<boolean>;
    disconnect: () => Promise<void>;
    requestConnect: (Config: any) => Promise<boolean>;
    accountId: string;
    requestTransfer: (args: {
        to: string;
        amount: number;
        opts?: {
            fee?: number;
            memo?: string;
            from_subaccount?: number;
            created_at_time?: {
                timestamp_nanos: number;
            };
        };
    }) => Promise<{
        height: number;
    }>;
    requestBalance: () => Promise<Array<{
        amount: number;
        canisterId: string;
        decimals: number;
        image?: string;
        name: string;
        symbol: string;
    }>>;
    getManagementCanister: () => Promise<ActorSubclass | undefined>;
};
declare class PlugWallet implements IConnector, IWalletConnector {
    #private;
    meta: {
        features: string[];
        icon: {
            light: any;
            dark: any;
        };
        id: string;
        name: string;
    };
    get identity(): any;
    get wallets(): {
        principal: string;
        accountId: string;
    }[];
    get principal(): string | undefined;
    get client(): any;
    get ic(): Plug | undefined;
    constructor(userConfig?: {});
    set config(config: {
        whitelist: string[];
        host: string;
        dev: boolean;
        onConnectionUpdate: () => void;
    });
    get config(): {
        whitelist: string[];
        host: string;
        dev: boolean;
        onConnectionUpdate: () => void;
    };
    init(): Promise<import("neverthrow").Err<never, {
        kind: InitError;
    }> | import("neverthrow").Ok<{
        isConnected: boolean;
    }, never>>;
    status(): Promise<unknown>;
    isConnected(): Promise<boolean>;
    createActor<Service>(canisterId: string, idlFactory: IDL.InterfaceFactory): Promise<import("neverthrow").Err<never, {
        kind: CreateActorError;
    }> | import("neverthrow").Ok<ActorSubclass<Service>, never>>;
    connect(): Promise<import("neverthrow").Ok<boolean, never> | import("neverthrow").Err<never, {
        kind: ConnectError;
    }>>;
    disconnect(): Promise<import("neverthrow").Ok<boolean, never> | import("neverthrow").Err<never, {
        kind: DisconnectError;
    }>>;
    requestTransfer(opts: {
        amount: number;
        to: string;
        symbol?: string;
        standard?: string;
        decimals?: number;
        fee?: number;
        memo?: bigint;
        createdAtTime?: Date;
        fromSubAccount?: number;
    }): Promise<import("neverthrow").Ok<{
        height: number;
    }, never> | import("neverthrow").Err<never, {
        kind: TransferError;
    }>>;
    queryBalance(): Promise<import("neverthrow").Err<never, {
        kind: BalanceError;
    }> | import("neverthrow").Ok<{
        amount: number;
        canisterId: string;
        decimals: number;
        image?: string | undefined;
        name: string;
        symbol: string;
    }[], never>>;
}
export { PlugWallet, };