import type { IConnector } from "./connectors";
import type { ActorSubclass, Agent } from "@dfinity/agent";
import type { IDL } from "@dfinity/candid";
import type { Principal } from "@dfinity/principal";
import { ConnectError, CreateActorError, DisconnectError, InitError } from "./connectors";
declare type Config = {
    whitelist: Array<string>;
    host: string;
    dev: Boolean;
};
declare type IC = {
    createActor: <T>(args: {
        canisterId: string;
        interfaceFactory: IDL.InterfaceFactory;
    }) => Promise<ActorSubclass<T>>;
    agent: Agent;
    getPrincipal: () => Promise<Principal>;
    isConnected: () => Promise<boolean>;
    disconnect: () => Promise<any>;
    requestConnect: (Config: any) => Promise<boolean>;
};
declare class InfinityWallet implements IConnector {
    #private;
    meta: {
        features: never[];
        icon: {
            light: any;
            dark: any;
        };
        id: string;
        name: string;
    };
    get identity(): any;
    get principal(): string | undefined;
    get client(): any;
    get ic(): IC | undefined;
    constructor(userConfig?: {});
    set config(config: Config);
    get config(): Config;
    init(): Promise<import("neverthrow").Err<never, {
        kind: InitError;
    }> | import("neverthrow").Ok<{
        isConnected: boolean;
    }, never>>;
    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;
    }>>;
}
export { InfinityWallet, };