import { type AccountSchema, AnyZodOrCoValueSchema, BaseAccountShape, type CoFeedSchema, type CoListSchema, type CoMapSchema, type CoProfileSchema, type CoRecordSchema, type DefaultProfileShape, type FileStreamSchema, type CoVectorSchema, ImageDefinition, type PlainTextSchema, type Simplify, ResolveQuery, RefsToResolveStrict } from "../../internal.js";
import { CoDiscriminatedUnionSchema, DiscriminableCoValueSchemas } from "./schemaTypes/CoDiscriminatedUnionSchema.js";
import { CoOptionalSchema } from "./schemaTypes/CoOptionalSchema.js";
import { SnapshotRefSchema } from "./schemaTypes/SnapshotRefSchema.js";
import type { CoreCoValueSchema } from "./schemaTypes/CoValueSchema.js";
import { RichTextSchema } from "./schemaTypes/RichTextSchema.js";
import { z } from "./zodReExport.js";
import { GroupSchema } from "./schemaTypes/GroupSchema.js";
export declare const coMapDefiner: <Shape extends z.core.$ZodLooseShape>(shape: Shape) => CoMapSchema<Shape>;
/**
 * Defines a collaborative account schema for Jazz applications.
 *
 * Creates an account schema that represents a user account with profile and root data.
 * Accounts are the primary way to identify and manage users in Jazz applications.
 *
 * @template Shape - The shape of the account schema extending BaseAccountShape
 * @param shape - The account schema shape. Defaults to a basic profile with name, inbox, and inboxInvite fields, plus an empty root object.
 *
 * @example
 * ```typescript
 * // Basic account with default profile
 * const BasicAccount = co.account();
 *
 * // Custom account with specific profile and root structure
 * const JazzAccount = co.account({
 *   profile: co.profile({
 *     name: z.string(),
 *     avatar: z.optional(z.string()),
 *   }),
 *   root: co.map({
 *     organizations: co.list(Organization),
 *     draftOrganization: DraftOrganization,
 *   }),
 * }).withMigration(async (account) => {
 *   // Migration logic for existing accounts
 *   if (!account.$jazz.has("profile")) {
 *     const group = Group.create();
 *     account.$jazz.set("profile", co.profile().create(
 *       { name: getRandomUsername() },
 *       group
 *     ));
 *     group.addMember("everyone", "reader");
 *   }
 * });
 * ```
 */
export declare const coAccountDefiner: <Shape extends BaseAccountShape>(shape?: Shape) => AccountSchema<Shape>;
export declare const coGroupDefiner: () => GroupSchema;
export declare const coRecordDefiner: <K extends z.core.$ZodString<string>, V extends AnyZodOrCoValueSchema>(_keyType: K, valueType: V) => CoRecordSchema<K, V>;
export declare const coListDefiner: <T extends AnyZodOrCoValueSchema>(element: T) => CoListSchema<T>;
export declare const coProfileDefiner: <Shape extends z.core.$ZodLooseShape = Simplify<DefaultProfileShape>>(shape?: Shape & Partial<DefaultProfileShape>) => CoProfileSchema<Shape>;
export declare const coFeedDefiner: <T extends AnyZodOrCoValueSchema>(element: T) => CoFeedSchema<T>;
export declare const coFileStreamDefiner: () => FileStreamSchema;
export declare const coVectorDefiner: (dimensions: number) => CoVectorSchema;
export declare const coPlainTextDefiner: () => PlainTextSchema;
export declare const coRichTextDefiner: () => RichTextSchema;
export type ImageDefinitionSchema = typeof ImageDefinition;
export declare const coImageDefiner: () => ImageDefinitionSchema;
export declare const coOptionalDefiner: <T extends CoreCoValueSchema>(schema: T) => CoOptionalSchema<T>;
export declare const coDiscriminatedUnionDefiner: <Options extends DiscriminableCoValueSchemas>(discriminator: string, schemas: Options) => CoDiscriminatedUnionSchema<Options>;
export declare const snapshotRefDefiner: <S extends CoreCoValueSchema, const R extends ResolveQuery<S> = true>(schema: S, options?: {
    cursorResolve?: RefsToResolveStrict<S, R>;
}) => SnapshotRefSchema<S, R>;
//# sourceMappingURL=zodCo.d.ts.map