import { AgentSecret, CryptoProvider, Everyone, InviteSecret, LocalNode, Peer, RawAccount, SessionID } from "cojson";
import { AnonymousJazzAgent, BranchDefinition, CoFieldInit, type CoMap, type CoValue, CoValueBase, CoValueClass, CoValueClassOrSchema, CoValueJazzApi, Group, ID, MaybeLoaded, Settled, Profile, RefIfCoValue, RefsToResolve, RefsToResolveStrict, Resolved, Schema, SubscribeListenerOptions, TypeSym, inspect, InstanceOfSchemaCoValuesMaybeLoaded, LoadedAndRequired, CoValueCursor, LoadCoValueCursorOption } from "../internal.js";
import type { CoreAccountSchema } from "../implementation/zodSchema/schemaTypes/AccountSchema.js";
import type { AccountSchema as HydratedAccountSchema } from "../implementation/zodSchema/schemaTypes/AccountSchema.js";
export type AccountCreationProps = {
    name: string;
    onboarding?: boolean;
};
/** @category Identity & Permissions */
export declare class Account extends CoValueBase implements CoValue {
    [TypeSym]: "Account";
    static coValueSchema?: HydratedAccountSchema;
    /**
     * Jazz methods for Accounts are inside this property.
     *
     * This allows Accounts to be used as plain objects while still having
     * access to Jazz methods.
     */
    $jazz: AccountJazzApi<this>;
    readonly profile: MaybeLoaded<Profile>;
    readonly root: MaybeLoaded<CoMap>;
    constructor(options: {
        fromRaw: RawAccount;
    });
    /**
     * Whether this account is the currently active account.
     */
    get isMe(): boolean;
    /**
     * Accept an invite to a `CoValue` or `Group`.
     *
     * @param valueID The ID of the `CoValue` or `Group` to accept the invite to.
     * @param inviteSecret The secret of the invite to accept.
     * @param coValueClass [Group] The class of the `CoValue` or `Group` to accept the invite to.
     * @returns The loaded `CoValue` or `Group`.
     */
    acceptInvite<S extends CoValueClassOrSchema>(valueID: string, inviteSecret: InviteSecret, coValueClass?: S): Promise<Settled<Resolved<InstanceOfSchemaCoValuesMaybeLoaded<S>, true>>>;
    getRoleOf(member: Everyone | ID<Account> | "me"): "admin" | undefined;
    canRead(value: CoValue): boolean;
    canWrite(value: CoValue): boolean;
    canManage(value: CoValue): boolean;
    canAdmin(value: CoValue): boolean;
    /** @private */
    static create<A extends Account>(this: CoValueClass<A> & typeof Account, options: {
        creationProps: {
            name: string;
        };
        initialAgentSecret?: AgentSecret;
        peers?: Peer[];
        crypto: CryptoProvider;
    }): Promise<A>;
    static getMe<A extends Account>(this: CoValueClass<A> & typeof Account): A;
    /**
     * @deprecated Use `co.account(...).createAs` instead.
     */
    static createAs<A extends Account>(this: CoValueClass<A> & typeof Account, worker: Account, options: {
        creationProps: {
            name: string;
        };
        onCreate?: (account: A, worker: Account, credentials: {
            accountID: string;
            accountSecret: AgentSecret;
        }) => Promise<void>;
        waitForSyncTimeout?: number;
    }): Promise<{
        credentials: {
            accountID: string;
            accountSecret: AgentSecret;
        };
        account: A;
    }>;
    static fromNode<A extends Account>(this: CoValueClass<A>, node: LocalNode): A;
    toJSON(): object | any[];
    [inspect](): object | any[];
    applyMigration(creationProps?: AccountCreationProps): Promise<void>;
    migrate(creationProps?: AccountCreationProps): void;
    /**
     * Load an `Account`
     * @category Subscription & Loading
     * @deprecated Use `co.account(...).load` instead.
     */
    static load<A extends Account, const R extends RefsToResolve<A> = true>(this: CoValueClass<A>, id: ID<A>, options?: {
        resolve?: RefsToResolveStrict<A, R>;
        loadAs?: Account | AnonymousJazzAgent;
    }): Promise<Settled<Resolved<A, R>>>;
    /**
     * Subscribe to an `Account`, when you have an ID but don't have an `Account` instance yet
     * @category Subscription & Loading
     * @deprecated Use `co.account(...).subscribe` instead.
     */
    static subscribe<A extends Account, const R extends RefsToResolve<A> = true>(this: CoValueClass<A>, id: ID<A>, listener: (value: Resolved<A, R>, unsubscribe: () => void) => void): () => void;
    static subscribe<A extends Account, const R extends RefsToResolve<A> = true>(this: CoValueClass<A>, id: ID<A>, options: SubscribeListenerOptions<A, R>, listener: (value: Resolved<A, R>, unsubscribe: () => void) => void): () => void;
}
declare class AccountJazzApi<A extends Account> extends CoValueJazzApi<A> {
    private account;
    raw: RawAccount;
    private coValueSchema;
    private descriptorCache;
    /**
     * Whether this account is the owner of the local node.
     *
     * @internal
     */
    isLocalNodeOwner: boolean;
    /** @internal */
    sessionID: SessionID | undefined;
    constructor(account: A, raw: RawAccount, coValueSchema: CoreAccountSchema);
    /**
     * Accounts have no owner. They can be accessed by everyone.
     */
    get owner(): undefined;
    /**
     * Set the value of a key in the account.
     *
     * @param key The key to set.
     * @param value The value to set.
     *
     * @category Content
     */
    set<K extends "root" | "profile">(key: K, value: CoFieldInit<LoadedAndRequired<A[K]>>): void;
    has(key: "root" | "profile"): boolean;
    /**
     * Get the descriptor for a given key
     * @internal
     */
    getDescriptor(key: string): Schema | undefined;
    /**
     * If property `prop` is a `coField.ref(...)`, you can use `account.$jazz.refs.prop` to access
     * the `Ref` instead of the potentially loaded/null value.
     *
     * This allows you to always get the ID or load the value manually.
     *
     * @category Content
     */
    get refs(): {
        profile: RefIfCoValue<Profile> | undefined;
        root: RefIfCoValue<CoMap> | undefined;
    };
    /** @category Subscription & Loading */
    ensureLoaded<A extends Account, const R extends RefsToResolve<A>>(this: AccountJazzApi<A>, options: {
        resolve: RefsToResolveStrict<A, R>;
        unstable_branch?: BranchDefinition;
        cursor?: LoadCoValueCursorOption;
    }): Promise<Resolved<A, R>>;
    /** @category Subscription & Loading */
    subscribe<A extends Account, const R extends RefsToResolve<A>>(this: AccountJazzApi<A>, listener: (value: Resolved<A, R>, unsubscribe: () => void) => void): () => void;
    subscribe<A extends Account, const R extends RefsToResolve<A>>(this: AccountJazzApi<A>, options: {
        resolve?: RefsToResolveStrict<A, R>;
        unstable_branch?: BranchDefinition;
        cursor?: CoValueCursor;
    }, listener: (value: Resolved<A, R>, unsubscribe: () => void) => void): () => void;
    /**
     * Wait for the `Account` to be uploaded to the other peers.
     *
     * @category Subscription & Loading
     */
    waitForSync(options?: {
        timeout?: number;
    }): Promise<unknown[]>;
    /**
     * Wait for all the available `CoValues` to be uploaded to the other peers.
     *
     * @category Subscription & Loading
     */
    waitForAllCoValuesSync(options?: {
        timeout?: number;
    }): Promise<unknown[][]>;
    get loadedAs(): Account | AnonymousJazzAgent;
}
export declare const AccountAndGroupProxyHandler: ProxyHandler<Account | Group>;
export type ControlledAccount = Account & {
    $jazz: {
        raw: RawAccount;
        isLocalNodeOwner: true;
        sessionID: SessionID;
    };
};
/** @category Identity & Permissions */
export declare function isControlledAccount(account: Account): account is ControlledAccount;
export type AccountClass<Acc extends Account> = CoValueClass<Acc> & {
    fromNode: (typeof Account)["fromNode"];
};
export {};
//# sourceMappingURL=account.d.ts.map