import { CoValueUniqueness } from "cojson";
import { Account, BranchDefinition, CoMap, DiscriminableCoValueSchemaDefinition, DiscriminableCoreCoValueSchema, Group, Settled, RefsToResolve, RefsToResolveStrict, Resolved, Simplify, SubscribeCallback, SubscribeListenerOptions, type Schema, CoValueCreateOptions, LoadCoValueCursorOption } from "../../../internal.js";
import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
import { CoMapSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
import { InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded } from "../typeConverters/InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded.js";
import { z } from "../zodReExport.js";
import { AnyZodOrCoValueSchema, AnyZodSchema } from "../zodSchema.js";
import { CoOptionalSchema } from "./CoOptionalSchema.js";
import { CoreCoValueSchema, CoreResolveQuery } from "./CoValueSchema.js";
import { SchemaPermissions } from "../schemaPermissions.js";
type CoMapSchemaInstance<Shape extends z.core.$ZodLooseShape> = Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap;
export declare class CoMapSchema<Shape extends z.core.$ZodLooseShape, CatchAll extends AnyZodOrCoValueSchema | unknown = unknown, Owner extends Account | Group = Account | Group, DefaultResolveQuery extends CoreResolveQuery = true> implements CoreCoMapSchema<Shape, CatchAll> {
    #private;
    private coValueClass;
    collaborative: true;
    builtin: "CoMap";
    shape: Shape;
    catchAll?: CatchAll;
    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;
    /**
     * Permissions to be used when creating or composing CoValues
     * @internal
     */
    get permissions(): SchemaPermissions;
    constructor(coreSchema: CoreCoMapSchema<Shape, CatchAll>, coValueClass: typeof CoMap);
    getDescriptorsSchema: () => CoMapDescriptorsSchema;
    create(init: CoMapSchemaInit<Shape>, options?: CoValueCreateOptions): CoMapInstanceShape<Shape, CatchAll> & CoMap;
    /** @deprecated Creating CoValues with an Account as owner is deprecated. Use a Group instead. */
    create(init: CoMapSchemaInit<Shape>, options?: CoValueCreateOptions<{}, Account | Group>): CoMapInstanceShape<Shape, CatchAll> & CoMap;
    load<const R extends RefsToResolve<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap> = DefaultResolveQuery>(id: string, options?: {
        resolve?: RefsToResolveStrict<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>;
        loadAs?: Account | AnonymousJazzAgent;
        skipRetry?: boolean;
        unstable_branch?: BranchDefinition;
        cursor?: LoadCoValueCursorOption;
    }): Promise<Settled<Resolved<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>>>;
    unstable_merge<const R extends RefsToResolve<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap> = DefaultResolveQuery>(id: string, options: {
        resolve?: RefsToResolveStrict<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>;
        loadAs?: Account | AnonymousJazzAgent;
        branch: BranchDefinition;
    }): Promise<void>;
    subscribe<const R extends RefsToResolve<CoMapSchemaInstance<Shape>> = DefaultResolveQuery>(id: string, listener: SubscribeCallback<Resolved<CoMapSchemaInstance<Shape>, R>>): () => void;
    subscribe<const R extends RefsToResolve<CoMapSchemaInstance<Shape>> = DefaultResolveQuery>(id: string, options: SubscribeListenerOptions<CoMapSchemaInstance<Shape>, R>, listener: SubscribeCallback<Resolved<CoMapSchemaInstance<Shape>, R>>): () => void;
    /** @deprecated Use `loadUnique` instead. */
    findUnique(unique: CoValueUniqueness["uniqueness"], ownerID: string, as?: Account | Group | AnonymousJazzAgent): string;
    /**
     * Get an existing unique CoMap or create a new one if it doesn't exist.
     *
     * Unlike `upsertUnique`, this method does NOT update existing values with the provided value.
     * The provided value is only used when creating a new CoMap.
     *
     * @example
     * ```ts
     * const settings = await UserSettings.getOrCreateUnique({
     *   value: { theme: "dark", language: "en" },
     *   unique: "user-settings",
     *   owner: me,
     * });
     * ```
     *
     * @param options The options for creating or loading the CoMap.
     * @returns Either an existing CoMap (unchanged), or a new initialised CoMap if none exists.
     * @category Subscription & Loading
     */
    getOrCreateUnique<const R extends RefsToResolve<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap> = DefaultResolveQuery>(options: {
        value: Simplify<CoMapSchemaInit<Shape>>;
        unique: CoValueUniqueness["uniqueness"];
        owner: Owner;
        resolve?: RefsToResolveStrict<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>;
    }): Promise<Settled<Resolved<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>>>;
    /**
     * @deprecated Use `getOrCreateUnique` instead. Note: getOrCreateUnique does not update existing values.
     * If you need to update, use getOrCreateUnique followed by direct property assignment.
     */
    upsertUnique<const R extends RefsToResolve<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap> = DefaultResolveQuery>(options: {
        value: Simplify<CoMapSchemaInit<Shape>>;
        unique: CoValueUniqueness["uniqueness"];
        owner: Owner;
        resolve?: RefsToResolveStrict<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>;
    }): Promise<Settled<Resolved<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>>>;
    loadUnique<const R extends RefsToResolve<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap> = DefaultResolveQuery>(unique: CoValueUniqueness["uniqueness"], ownerID: string, options?: {
        resolve?: RefsToResolveStrict<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>;
        loadAs?: Account | AnonymousJazzAgent;
    }): Promise<Settled<Resolved<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>>>;
    /**
     * @deprecated `co.map().catchall` will be removed in an upcoming version.
     *
     * Use a `co.record` nested inside a `co.map` if you need to store key-value properties.
     *
     * @example
     * ```ts
     * // Instead of:
     * const Image = co.map({
     *   original: co.fileStream(),
     * }).catchall(co.fileStream());
     *
     * // Use:
     * const Image = co.map({
     *   original: co.fileStream(),
     *   resolutions: co.record(z.string(), co.fileStream()),
     * });
     * ```
     */
    catchall<T extends AnyZodOrCoValueSchema>(schema: T): CoMapSchema<Shape, T>;
    withMigration(migration: CoMapMigration<Shape>): this;
    getCoValueClass(): typeof CoMap;
    optional(): CoOptionalSchema<this>;
    /**
     * Creates a new CoMap schema by picking the specified keys from the original schema.
     * The new CoMap will **not** inherit any configurations (migration, catchall, permissions, default resolve query)
     *
     * @param keys - The keys to pick from the original schema.
     * @returns A new CoMap schema with the picked keys.
     */
    pick<Keys extends keyof Shape>(keys: {
        [key in Keys]: true;
    }): CoMapSchema<Simplify<Pick<Shape, Keys>>, unknown, Owner>;
    /**
     * Creates a new CoMap schema by omitting the specified keys from the original schema.
     * The new CoMap will **not** inherit any configurations (migration, catchall, permissions, default resolve query)
     *
     * @param keys - The keys to omit from the original schema.
     * @returns A new CoMap schema with the omitted keys.
     */
    omit<Keys extends keyof Shape>(keys: {
        [key in Keys]: true;
    }): CoMapSchema<Simplify<Omit<Shape, Keys>>, unknown, Owner>;
    /**
     * Creates a new CoMap schema by making all fields optional.
     * The new CoMap will **not** inherit any configurations (migration, permissions, default resolve query) except catchall
     *
     * @returns A new CoMap schema with all fields optional.
     */
    partial<Keys extends keyof Shape = keyof Shape>(keys?: {
        [key in Keys]: true;
    }): CoMapSchema<PartialShape<Shape, Keys>, CatchAll, Owner>;
    /**
     * Creates a new CoMap schema by extending the current schema with additional fields.
     * The new CoMap **will** inherit all configurations (migration, catchall, permissions, default resolve query)
     *
     * @param shape - The shape object with additional fields to add to the schema.
     * @returns A new CoMap schema with the additional fields.
     */
    extend<ExtendShape extends z.core.$ZodLooseShape>(shape: ExtendShape): CoMapSchema<z.core.util.Extend<Shape, ExtendShape>, CatchAll, Owner, DefaultResolveQuery>;
    /**
     * Creates a new CoMap schema by extending the current schema with additional fields,
     * while also making sure that no existing fields are accidentally overridden.
     * The new CoMap **will** inherit all configurations (migration, catchall, permissions, default resolve query)
     *
     * @param shape - The shape object with additional fields to add to the schema.
     * @returns A new CoMap schema with the additional fields.
     */
    safeExtend<ExtendShape extends z.core.$ZodLooseShape>(shape: SafeExtendShape<Shape, ExtendShape> & Partial<Record<keyof Shape, AnyZodOrCoValueSchema>>): CoMapSchema<z.core.util.Extend<Shape, ExtendShape>, CatchAll, Owner, DefaultResolveQuery>;
    /**
     * 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<const R extends RefsToResolve<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap> = true>(resolveQuery: RefsToResolveStrict<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, R>): CoMapSchema<Shape, CatchAll, Owner, R>;
    /**
     * Configure permissions to be used when creating or composing CoValues
     */
    withPermissions(permissions: Omit<SchemaPermissions, "writer">): CoMapSchema<Shape, CatchAll, Owner, DefaultResolveQuery>;
    /**
     * Creates a copy of this schema, preserving all previous configuration
     */
    private copy;
}
export declare function createCoreCoMapSchema<Shape extends z.core.$ZodLooseShape, CatchAll extends AnyZodOrCoValueSchema | unknown = unknown>(shape: Shape, catchAll?: CatchAll): CoreCoMapSchema<Shape, CatchAll>;
export interface CoMapSchemaDefinition<Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape, CatchAll extends AnyZodOrCoValueSchema | unknown = unknown> extends DiscriminableCoValueSchemaDefinition {
    shape: Shape;
    catchall?: CatchAll;
}
export type CoMapDescriptorsSchema = {
    shape: Record<string, Schema>;
    catchall?: Schema;
};
export interface CoreCoMapSchema<Shape extends z.core.$ZodLooseShape = z.core.$ZodLooseShape, CatchAll extends AnyZodOrCoValueSchema | unknown = unknown> extends DiscriminableCoreCoValueSchema {
    builtin: "CoMap";
    shape: Shape;
    catchAll?: CatchAll;
    getDescriptorsSchema: () => CoMapDescriptorsSchema;
    getDefinition: () => CoMapSchemaDefinition;
}
type CoMapMigration<Shape extends z.core.$ZodLooseShape> = (value: Resolved<Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap, true>) => undefined;
export type CoMapInstanceShape<Shape extends z.core.$ZodLooseShape, CatchAll extends AnyZodOrCoValueSchema | unknown = unknown> = {
    readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
} & (CatchAll extends AnyZodOrCoValueSchema ? {
    readonly [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
} : {});
export type CoMapInstanceCoValuesMaybeLoaded<Shape extends z.core.$ZodLooseShape> = {
    readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesMaybeLoaded<Shape[key]>;
};
export type PartialShape<Shape extends z.core.$ZodLooseShape, PartialKeys extends keyof Shape = keyof Shape> = Simplify<{
    -readonly [key in keyof Shape]: key extends PartialKeys ? Shape[key] extends AnyZodSchema ? z.ZodOptional<Shape[key]> : Shape[key] extends CoreCoValueSchema ? CoOptionalSchema<Shape[key]> : never : Shape[key];
}>;
export type SafeExtendShape<Base extends z.core.$ZodLooseShape, Ext extends z.core.$ZodLooseShape> = {
    [K in keyof Ext]: K extends keyof Base ? Base[K] extends z.core.SomeType ? Ext[K] extends z.core.SomeType ? InstanceOrPrimitiveOfSchema<Ext[K]> extends InstanceOrPrimitiveOfSchema<Base[K]> ? z.core.input<Ext[K]> extends z.core.input<Base[K]> ? Ext[K] : never : never : never : Ext[K] extends z.core.SomeType ? never : InstanceOrPrimitiveOfSchema<Ext[K]> extends InstanceOrPrimitiveOfSchema<Base[K]> ? Ext[K] : never : Ext[K];
};
export {};
//# sourceMappingURL=CoMapSchema.d.ts.map