import { Account, BranchDefinition, CoMapSchemaDefinition, Group, Settled, RefsToResolveStrict, RefsToResolve, Resolved, Simplify, SubscribeCallback, SubscribeListenerOptions } from "../../../internal.js";
import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
import { z } from "../zodReExport.js";
import { AnyZodOrCoValueSchema, Loaded, ResolveQuery } from "../zodSchema.js";
import { CoMapSchema, CoMapDescriptorsSchema, CoreCoMapSchema } from "./CoMapSchema.js";
import { CoOptionalSchema } from "./CoOptionalSchema.js";
import { CoreResolveQuery } from "./CoValueSchema.js";
import { AgentSecret } from "cojson";
export type BaseProfileShape = {
    name: z.core.$ZodString<string>;
    inbox?: z.core.$ZodOptional<z.core.$ZodString>;
    inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
};
export type BaseAccountShape = {
    profile: CoreCoMapSchema<BaseProfileShape>;
    root: CoreCoMapSchema;
};
export type DefaultAccountShape = {
    profile: CoMapSchema<BaseProfileShape>;
    root: CoMapSchema<{}>;
};
export declare class AccountSchema<Shape extends BaseAccountShape = DefaultAccountShape, DefaultResolveQuery extends CoreResolveQuery = true> implements CoreAccountSchema<Shape> {
    #private;
    private coValueClass;
    collaborative: true;
    builtin: "Account";
    shape: Shape;
    getDescriptorsSchema: () => CoMapDescriptorsSchema;
    getDefinition: () => CoMapSchemaDefinition;
    getValidationSchema: () => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
    /**
     * Default resolve query to be used when loading instances of this schema.
     * This resolve query will be used when no resolve query is provided to the load method.
     * @default true
     */
    resolveQuery: DefaultResolveQuery;
    constructor(coreSchema: CoreAccountSchema<Shape>, coValueClass: typeof Account);
    create(options: Simplify<Parameters<(typeof Account)["create"]>[0]>): Promise<AccountInstance<Shape>>;
    load<const R extends ResolveQuery<AccountSchema<Shape>> = DefaultResolveQuery>(id: string, options?: {
        loadAs?: Account | AnonymousJazzAgent;
        resolve?: RefsToResolveStrict<AccountSchema<Shape>, R>;
    }): Promise<Settled<Loaded<AccountSchema<Shape>, R>>>;
    /**
     * Creates a new account as a worker account, useful for generating controlled accounts from a server environment.
     * This method initializes a new account, applies migrations, invokes the `onCreate` callback, and then shuts down the temporary node to avoid memory leaks.
     * Returns the created account (loaded on the worker) and its credentials.
     *
     * The method internally calls `waitForAllCoValuesSync` on the new account. If many CoValues are created during `onCreate`,
     * consider adjusting the timeout using the `waitForSyncTimeout` option.
     *
     * @param worker - The worker account to create the new account from
     * @param options.creationProps - The creation properties for the new account
     * @param options.onCreate - The callback to use to initialize the account after it is created
     * @param options.waitForSyncTimeout - The timeout for the sync to complete
     * @returns The credentials and the created account loaded by the worker account
     *
     *
     * @example
     * ```ts
     * const { credentials, account } = await AccountSchema.createAs(worker, {
     *   creationProps: { name: "My Account" },
     *   onCreate: async (account, worker, credentials) => {
     *     account.root.$jazz.owner.addMember(worker, "writer");
     *   },
     * });
     * ```
     */
    createAs(worker: Account, options: {
        creationProps: {
            name: string;
        };
        onCreate?: (account: AccountInstance<Shape>, worker: Account, credentials: {
            accountID: string;
            accountSecret: AgentSecret;
        }) => Promise<void>;
        waitForSyncTimeout?: number;
    }): Promise<{
        credentials: {
            accountID: string;
            accountSecret: AgentSecret;
        };
        account: Loaded<AccountSchema<Shape>, DefaultResolveQuery>;
    }>;
    unstable_merge<R extends ResolveQuery<AccountSchema<Shape>> = DefaultResolveQuery>(id: string, options: {
        loadAs?: Account | AnonymousJazzAgent;
        resolve?: RefsToResolveStrict<AccountSchema<Shape>, R>;
        branch: BranchDefinition;
    }): Promise<void>;
    subscribe<const R extends RefsToResolve<Simplify<AccountInstance<Shape>>> = DefaultResolveQuery>(id: string, listener: SubscribeCallback<Resolved<Simplify<AccountInstance<Shape>>, R>>): () => void;
    subscribe<const R extends RefsToResolve<Simplify<AccountInstance<Shape>>> = DefaultResolveQuery>(id: string, options: SubscribeListenerOptions<Simplify<AccountInstance<Shape>>, R>, listener: SubscribeCallback<Resolved<Simplify<AccountInstance<Shape>>, R>>): () => void;
    getMe(): Loaded<this, true>;
    withMigration(migration: (account: Loaded<AccountSchema<Shape>>, creationProps?: {
        name: string;
    }) => void): AccountSchema<Shape, DefaultResolveQuery>;
    getCoValueClass(): typeof Account;
    optional(): CoOptionalSchema<this>;
    /**
     * Adds a default resolve query to be used when loading instances of this schema.
     * This resolve query will be used when no resolve query is provided to the load method.
     */
    resolved<R extends ResolveQuery<AccountSchema<Shape>>>(resolveQuery: RefsToResolveStrict<AccountSchema<Shape>, R>): AccountSchema<Shape, R>;
}
export declare function createCoreAccountSchema<Shape extends BaseAccountShape>(shape: Shape): CoreAccountSchema<Shape>;
export type DefaultProfileShape = {
    name: z.core.$ZodString<string>;
    inbox: z.core.$ZodOptional<z.core.$ZodString>;
    inboxInvite: z.core.$ZodOptional<z.core.$ZodString>;
};
export type CoProfileSchema<Shape extends z.core.$ZodLooseShape = DefaultProfileShape, CatchAll extends AnyZodOrCoValueSchema | unknown = unknown> = CoMapSchema<Shape & DefaultProfileShape, CatchAll, Group>;
export interface CoreAccountSchema<Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape> extends Omit<CoreCoMapSchema<Shape>, "builtin"> {
    builtin: "Account";
}
export type AccountInstance<Shape extends z.core.$ZodLooseShape> = {
    readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
} & Account;
//# sourceMappingURL=AccountSchema.d.ts.map