import { AgentSecret, CryptoProvider, LocalNode, Peer, SessionID, StorageAPI } from "cojson";
import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
import { type Account, type AccountClass } from "../coValues/account.js";
import { CoValueFromRaw, type CoreAccountSchema, type ID, type InstanceOfSchema, type SyncWhen } from "../internal.js";
import { AuthCredentials, NewAccountProps } from "../types.js";
import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
export type Credentials = {
    accountID: ID<Account>;
    secret: AgentSecret;
};
export interface SessionProvider {
    acquireSession: (accountID: ID<Account>, crypto: CryptoProvider) => Promise<{
        sessionID: SessionID;
        sessionDone: () => void;
    }>;
    persistSession: (accountID: ID<Account>, sessionID: SessionID) => Promise<{
        sessionDone: () => void;
    }>;
}
export declare class MockSessionProvider implements SessionProvider {
    acquireSession(accountID: ID<Account>, crypto: CryptoProvider): Promise<{
        sessionID: SessionID;
        sessionDone: () => void;
    }>;
    persistSession(_accountID: ID<Account>, _sessionID: SessionID): Promise<{
        sessionDone: () => void;
    }>;
}
export type AuthResult = {
    type: "existing";
    username?: string;
    credentials: Credentials;
    saveCredentials?: (credentials: Credentials) => Promise<void>;
    onSuccess: () => void;
    onError: (error: string | Error) => void;
    logOut: () => Promise<void>;
} | {
    type: "new";
    creationProps: {
        name: string;
        anonymous?: boolean;
        other?: Record<string, unknown>;
    };
    initialSecret?: AgentSecret;
    saveCredentials: (credentials: Credentials) => Promise<void>;
    onSuccess: () => void;
    onError: (error: string | Error) => void;
    logOut: () => Promise<void>;
};
export type JazzContextWithAccount<Acc extends Account> = {
    node: LocalNode;
    account: Acc;
    done: () => void;
    logOut: () => Promise<void>;
};
export type JazzContextWithAgent = {
    agent: AnonymousJazzAgent;
    done: () => void;
    logOut: () => Promise<void>;
};
export type JazzContext<Acc extends Account> = JazzContextWithAccount<Acc> | JazzContextWithAgent;
export declare function createJazzContextFromExistingCredentials<S extends (AccountClass<Account> & CoValueFromRaw<Account>) | CoreAccountSchema>({ credentials, peers, syncWhen, crypto, storage, AccountSchema: PropsAccountSchema, sessionProvider, onLogOut, asActiveAccount, }: {
    credentials: Credentials;
    peers: Peer[];
    syncWhen?: SyncWhen;
    crypto: CryptoProvider;
    AccountSchema?: S;
    sessionProvider: SessionProvider;
    onLogOut?: () => void;
    storage?: StorageAPI;
    asActiveAccount: boolean;
}): Promise<JazzContextWithAccount<InstanceOfSchema<S>>>;
export declare function createJazzContextForNewAccount<S extends (AccountClass<Account> & CoValueFromRaw<Account>) | CoreAccountSchema>({ creationProps, initialAgentSecret, peers, syncWhen, crypto, AccountSchema: PropsAccountSchema, onLogOut, storage, sessionProvider, }: {
    creationProps: {
        name: string;
    };
    initialAgentSecret?: AgentSecret;
    peers: Peer[];
    syncWhen?: SyncWhen;
    crypto: CryptoProvider;
    AccountSchema?: S;
    onLogOut?: () => Promise<void>;
    storage?: StorageAPI;
    sessionProvider: SessionProvider;
}): Promise<JazzContextWithAccount<InstanceOfSchema<S>>>;
export declare function createJazzContext<S extends (AccountClass<Account> & CoValueFromRaw<Account>) | CoreAccountSchema>(options: {
    credentials?: AuthCredentials;
    newAccountProps?: NewAccountProps;
    peers: Peer[];
    syncWhen?: SyncWhen;
    crypto: CryptoProvider;
    defaultProfileName?: string;
    AccountSchema?: S;
    sessionProvider: SessionProvider;
    authSecretStorage: AuthSecretStorage;
    storage?: StorageAPI;
}): Promise<{
    authSecretStorage: AuthSecretStorage;
    node: LocalNode;
    account: InstanceOfSchema<S>;
    done: () => void;
    logOut: () => Promise<void>;
}>;
export declare function createAnonymousJazzContext({ peers, syncWhen, crypto, storage, }: {
    peers: Peer[];
    syncWhen?: SyncWhen;
    crypto: CryptoProvider;
    storage?: StorageAPI;
}): JazzContextWithAgent;
//# sourceMappingURL=createContext.d.ts.map