import { type CoValueUniqueness, type CojsonInternalTypes, type RawCoValue } from "cojson";
import { Account, AnonymousJazzAgent, CoValueClassOrSchema, CoValueLoadingState, NotLoadedCoValueState, Group, Loaded, Inaccessible, MaybeLoaded, OnCreateCallback, Settled, RefsToResolve, RefsToResolveStrict, ResolveQuery, ResolveQueryStrict, Resolved, SubscriptionScope, TypeSym, NotLoaded, inspect, LocalValidationMode, CoValueCursor, LoadCoValueCursorOption } from "../internal.js";
import type { BranchDefinition, CoValueErrorState } from "../subscribe/types.js";
import { CoValueHeader } from "cojson";
import { CoreCoValueSchema } from "../implementation/zodSchema/schemaTypes/CoValueSchema.js";
/** @category Abstract interfaces */
export interface CoValueClass<Value extends CoValue = CoValue, Schema extends CoreCoValueSchema = CoreCoValueSchema> {
    coValueSchema?: Schema;
    /** @ignore */
    new (...args: any[]): Value;
}
export interface CoValueFromRaw<V extends CoValue> {
    fromRaw(raw: V["$jazz"]["raw"]): V;
}
/** @category Abstract interfaces */
export interface CoValue {
    /** @category Type Helpers */
    [TypeSym]: string;
    $jazz: {
        /** @category Content */
        readonly id: ID<CoValue>;
        /** @category Content */
        loadingState: typeof CoValueLoadingState.LOADED;
        /** @category Collaboration */
        owner?: Group;
        /** @internal */
        readonly loadedAs: Account | AnonymousJazzAgent;
        /** @category Internals */
        raw: RawCoValue;
        /** @internal */
        _subscriptionScope?: SubscriptionScope<CoValue>;
        isBranched: boolean;
        branchName: string | undefined;
        unstable_merge: () => void;
        cursor: CoValueCursor | undefined;
        createCursor: () => CoValueCursor;
    };
    /**
     * Whether the CoValue is loaded. Can be used to distinguish between loaded and {@link NotLoaded} CoValues.
     * For more information about the CoValue's loading state, use {@link $jazz.loadingState}.
     */
    $isLoaded: true;
    /** @category Stringifying & Inspection */
    toJSON(key?: string, seenAbove?: ID<CoValue>[]): any[] | object | string;
    /** @category Stringifying & Inspection */
    [inspect](): any;
}
export declare function isCoValue(value: any): value is CoValue;
export declare function isCoValueClass<V extends CoValue>(value: any): value is CoValueClass<V> & CoValueFromRaw<V>;
/**
 * IDs are unique identifiers for `CoValue`s.
 * Can be used with a type argument to refer to a specific `CoValue` type.
 *
 * @example
 *
 * ```ts
 * type AccountID = ID<Account>;
 * ```
 *
 * @category CoValues
 */
export type ID<T> = string;
export declare function getUnloadedCoValueWithoutId<T extends CoValue>(loadingState: NotLoadedCoValueState): NotLoaded<T>;
export declare function createSettledCoValue<T extends CoValue>(id: ID<T>, loadingState: CoValueErrorState): Settled<T>;
export declare function createUnloadedCoValue<T extends CoValue>(id: ID<T>, loadingState: NotLoadedCoValueState): NotLoaded<T>;
export declare function loadCoValueWithoutMe<V extends CoValue, const R extends RefsToResolve<V> = true>(cls: CoValueClass<V>, id: ID<CoValue>, options?: {
    resolve?: RefsToResolveStrict<V, R>;
    loadAs?: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
    unstable_branch?: BranchDefinition;
    cursor?: LoadCoValueCursorOption;
}): Promise<Settled<Resolved<V, R>>>;
export declare function loadCoValue<V extends CoValue, const R extends RefsToResolve<V>>(cls: CoValueClass<V>, id: ID<CoValue>, options: {
    resolve?: RefsToResolveStrict<V, R>;
    loadAs: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
    unstable_branch?: BranchDefinition;
    cursor?: LoadCoValueCursorOption;
}): Promise<Settled<Resolved<V, R>>>;
export declare function ensureCoValueLoaded<V extends CoValue, const R extends RefsToResolve<V>>(existing: V, options?: {
    resolve?: RefsToResolveStrict<V, R>;
    unstable_branch?: BranchDefinition;
    cursor?: LoadCoValueCursorOption;
} | undefined): Promise<Resolved<V, R>>;
type SubscribeListener<V extends CoValue, R extends RefsToResolve<V>> = (value: Resolved<V, R>, unsubscribe: () => void) => void;
export type SubscribeCallback<V> = (value: V, unsubscribe: () => void) => void;
export type SubscribeListenerOptions<V extends CoValue, R extends RefsToResolve<V>> = {
    resolve?: RefsToResolveStrict<V, R>;
    loadAs?: Account | AnonymousJazzAgent;
    onError?: (value: NotLoaded<V>) => void;
    /**
     * @deprecated Use `onError` instead. This callback will be removed in a future version.
     */
    onUnauthorized?: (value: NotLoaded<V>) => void;
    /**
     * @deprecated Use `onError` instead. This callback will be removed in a future version.
     */
    onUnavailable?: (value: NotLoaded<V>) => void;
    unstable_branch?: BranchDefinition;
    cursor?: CoValueCursor;
};
export type SubscribeRestArgs<V extends CoValue, R extends RefsToResolve<V>> = [options: SubscribeListenerOptions<V, R>, listener: SubscribeListener<V, R>] | [listener: SubscribeListener<V, R>];
export declare function parseSubscribeRestArgs<V extends CoValue, R extends RefsToResolve<V>>(args: SubscribeRestArgs<V, R>): {
    options: SubscribeListenerOptions<V, R>;
    listener: SubscribeListener<V, R>;
};
export declare function subscribeToCoValueWithoutMe<V extends CoValue, const R extends RefsToResolve<V> = true>(cls: CoValueClass<V>, id: ID<CoValue>, options: SubscribeListenerOptions<V, R>, listener: SubscribeListener<V, R>): () => void;
export declare function subscribeToCoValue<V extends CoValue, const R extends RefsToResolve<V> = true>(cls: CoValueClass<V>, id: ID<CoValue>, options: {
    resolve?: RefsToResolveStrict<V, R>;
    loadAs: Account | AnonymousJazzAgent;
    onError?: (value: Inaccessible<V>) => void;
    /**
     * @deprecated Use `onError` instead. This callback will be removed in a future version.
     */
    onUnavailable?: (value: Inaccessible<V>) => void;
    /**
     * @deprecated Use `onError` instead. This callback will be removed in a future version.
     */
    onUnauthorized?: (value: Inaccessible<V>) => void;
    syncResolution?: boolean;
    skipRetry?: boolean;
    unstable_branch?: BranchDefinition;
    cursor?: CoValueCursor;
}, listener: SubscribeListener<V, R>): () => void;
export declare function subscribeToExistingCoValue<V extends CoValue, const R extends RefsToResolve<V>>(existing: V, options: {
    resolve?: RefsToResolveStrict<V, R>;
    onError?: (value: NotLoaded<V>) => void;
    /**
     * @deprecated Use `onError` instead. This callback will be removed in a future version.
     */
    onUnavailable?: (value: NotLoaded<V>) => void;
    /**
     * @deprecated Use `onError` instead. This callback will be removed in a future version.
     */
    onUnauthorized?: (value: NotLoaded<V>) => void;
    unstable_branch?: BranchDefinition;
    cursor?: CoValueCursor;
} | undefined, listener: SubscribeListener<V, R>): () => void;
export declare function isAccountInstance(instance: unknown): instance is Account;
export declare function isAnonymousAgentInstance(instance: unknown): instance is AnonymousJazzAgent;
export declare function isAccountOrGroup(instance: unknown): instance is Account | Group;
export type CoValueCreateOptions<MoreOptions extends object = {}, Owner extends Group | Account = Group> = undefined | Owner | (({
    owner: Owner;
    unique: CoValueUniqueness["uniqueness"];
    validation?: LocalValidationMode;
} | {
    owner?: Owner;
    unique?: undefined;
    validation?: LocalValidationMode;
}) & MoreOptions);
export type CoValueCreateOptionsInternal = CoValueCreateOptions<{
    onCreate?: OnCreateCallback;
    firstComesWins?: boolean;
    restrictDeletion?: boolean;
}, Account | Group>;
export declare function parseCoValueCreateOptions(options: CoValueCreateOptionsInternal): {
    owner: Group;
    uniqueness?: CoValueUniqueness;
    firstComesWins: boolean;
    restrictDeletion?: boolean;
};
export declare function accountOrGroupToGroup(accountOrGroup: Account | Group): Group;
export declare function parseGroupCreateOptions(options: {
    owner?: Account;
    name?: string;
} | Account | undefined): {
    owner: Account;
    name?: string;
};
export declare function getIdFromHeader(header: CoValueHeader, loadAs?: Account | AnonymousJazzAgent | Group): `co_z${string}`;
export declare function unstable_loadUnique<S extends CoValueClassOrSchema, const R extends ResolveQuery<S>>(schema: S, options: {
    unique: CoValueUniqueness["uniqueness"];
    onCreateWhenMissing?: () => void;
    onUpdateWhenFound?: (value: Loaded<S, R>) => void;
    owner: Account | Group;
    resolve?: ResolveQueryStrict<S, R>;
}): Promise<MaybeLoaded<Loaded<S, R>>>;
export type CoValueHeaderType = "comap" | "colist" | "costream" | "coplaintext";
/**
 * Get the CoValueHeaderType from a CoValue class.
 * Throws for unsupported types (Group, Account, BinaryCoStream).
 */
export declare function getUniqueHeaderType(schema: CoValueClassOrSchema): CoValueHeaderType;
/**
 * Generate a unique header for a CoValue class.
 * Throws for unsupported types (Group, Account, BinaryCoStream).
 */
export declare function getUniqueHeader(type: CoValueHeaderType, unique: CoValueUniqueness["uniqueness"], ownerID: ID<Account> | ID<Group>): CoValueHeader;
export declare function internalLoadUnique<V extends CoValue, R extends RefsToResolve<V>>(cls: CoValueClass<V>, options: {
    unique: CoValueUniqueness["uniqueness"];
    type: CoValueHeaderType;
    onCreateWhenMissing?: () => void;
    onUpdateWhenFound?: (value: Resolved<V, R>) => void;
    owner: Account | Group;
    resolve?: RefsToResolveStrict<V, R>;
}): Promise<Settled<Resolved<V, R>>>;
/**
 * Deeply export a CoValue to a content piece.
 *
 * @param cls - The class of the CoValue to export.
 * @param id - The ID of the CoValue to export.
 * @param options - The options for the export.
 * @returns The content pieces that were exported.
 *
 * @example
 * ```ts
 * const Address = co.map({
 *   street: z.string(),
 *   city: z.string(),
 * });
 *
 * const Person = co.map({
 *   name: z.string(),
 *   address: Address,
 * });
 *
 * const group = Group.create();
 * const address = Address.create(
 *   { street: "123 Main St", city: "New York" },
 *   group,
 * );
 * const person = Person.create({ name: "John", address }, group);
 * group.addMember("everyone", "reader");
 *
 * // Export with nested references resolved, values can be serialized to JSON
 * const exportedWithResolve = await exportCoValue(Person, person.id, {
 *   resolve: { address: true },
 * });
 *
 * // In another client or session
 * // Load the exported content pieces into the node, they will be persisted
 * importContentPieces(exportedWithResolve);
 *
 * // Now the person can be loaded from the node, even offline
 * const person = await loadCoValue(Person, person.id, {
 *   resolve: { address: true },
 * });
 * ```
 */
export declare function exportCoValue<S extends CoValueClassOrSchema, const R extends ResolveQuery<S>>(cls: S, id: ID<CoValue>, options: {
    resolve?: ResolveQueryStrict<S, R>;
    loadAs: Account | AnonymousJazzAgent;
    skipRetry?: boolean;
    bestEffortResolution?: boolean;
    unstable_branch?: BranchDefinition;
    cursor?: CoValueCursor;
}): Promise<import("cojson/dist/sync.js").NewContentMessage[] | null>;
export declare function exportCoValueFromSubscription<V>(subscription: SubscriptionScope<CoValue>): ExportedCoValue<V>;
export type ExportedID<V> = string & {
    _exportedID: V;
};
export type ExportedCoValue<V> = {
    id: ExportedID<V>;
    contentPieces: CojsonInternalTypes.NewContentMessage[];
};
/**
 * Import content pieces into the node.
 *
 * @param contentPieces - The content pieces to import.
 * @param loadAs - The account to load the content pieces as.
 */
export declare function importContentPieces(contentPieces: CojsonInternalTypes.NewContentMessage[], loadAs?: Account | AnonymousJazzAgent): void;
export declare function unstable_mergeBranch(subscriptionScope: SubscriptionScope<CoValue>): void;
export declare function unstable_mergeBranchWithResolve<S extends CoValueClassOrSchema, const R extends ResolveQuery<S>>(cls: S, id: ID<CoValue>, options: {
    resolve?: ResolveQueryStrict<S, R>;
    loadAs?: Account | AnonymousJazzAgent;
    branch: BranchDefinition;
}): Promise<void>;
/**
 * Permanently delete a group of coValues
 *
 * This operation is irreversible and will permanently delete the coValues from the local machine and the sync servers.
 *
 */
export declare function deleteCoValues<S extends CoValueClassOrSchema, const R extends ResolveQuery<S>>(cls: S, id: ID<CoValue>, options?: {
    resolve?: ResolveQueryStrict<S, R>;
    loadAs?: Account | AnonymousJazzAgent;
}): Promise<void>;
export {};
//# sourceMappingURL=interfaces.d.ts.map