/**
 * Thrown at the end of a `mutateGraph` transaction callback to force the whole
 * transaction to roll back when any write resolver failed, while carrying the
 * graphql execution result so the caller still receives the `errors` payload.
 *
 * graphql-js swallows a resolver throw into `result.errors` and resolves the
 * execution promise, so a multi-field mutation whose first field applied and
 * whose second field threw would otherwise commit a partial write. Throwing
 * this sentinel out of the transaction callback makes the apply all-or-nothing
 * (matching the RPC batch path) without throwing to the app.
 */
export declare class MutateGraphWriteRollback extends Error {
    #private;
    constructor(result: unknown);
    get result(): unknown;
}
/**
 * Marker a plugin mutation resolver throws to force its whole `mutateGraph`
 * transaction to roll back. graphql-js swallows a resolver throw into
 * `result.errors`, so a plugin op that performs several writes (e.g. an MLS
 * ratchet advance followed by a roster write) could otherwise commit a partial
 * result when a later step fails. A resolver that wraps such an op rethrows this
 * marker on any internal failure; `mutateGraph` scans the execution errors for
 * it and rolls back, matching the core-model write-failure path.
 */
export declare class TransactionFatalError extends Error {
    #private;
    constructor(message: string, options?: {
        cause?: unknown;
        extensions?: Record<string, unknown>;
    });
    get extensions(): Record<string, unknown> | undefined;
}
/** Whether `err` is a {@link TransactionFatalError} marker. */
export declare function isTransactionFatal(err: unknown): boolean;
/**
 * Thrown by the HLC mint gate when a local write is attempted before
 * `engine.ready()` has resolved. The clock refuses to author a timestamp until
 * identity verification has opened the gate, so a write that skipped `ready()`
 * (or raced ahead of it) surfaces this rather than minting under an unverified
 * identity.
 */
export declare class EngineNotReadyError extends Error {
    constructor();
}
/**
 * Thrown by `engine.ready()` when the database was created under one identity
 * and is being reopened under a different one. The engine binds an identity at
 * construction and never migrates a database between identities, so a mismatch
 * is terminal for the instance — the message points the operator at supplying
 * the original identity or, for a deliberate re-home, the offline adoption tool.
 */
export declare class IdentityMismatchError extends Error {
    #private;
    constructor(params: {
        seeded: string;
        opening: string;
    });
    /** The nodeID the database was first sealed under. */
    get seeded(): string;
    /** The nodeID the engine is now being opened under. */
    get opening(): string;
}
export declare class MutationBatchAccessDeniedError extends Error {
    constructor();
}
export declare class InvalidMutationSignatureError extends Error {
    constructor();
}
/** Membership could not be checked. No write was applied; callers may retry. */
export declare class MembershipCheckUnavailableError extends Error {
    #private;
    constructor(params: {
        docID?: string;
        circleID?: string;
        cause?: unknown;
    });
    get code(): 'MEMBERSHIP_CHECK_UNAVAILABLE';
    get retryable(): true;
    get docID(): string | undefined;
    get extensions(): {
        code: string;
        retryable: true;
        docID?: string;
    };
}
/**
 * Refuses an access-default change made for another owner when the signer holds
 * no present, unrevoked `document/share` delegation from that owner covering every
 * document of the model.
 */
export declare class AccessDefaultOwnerDeniedError extends Error {
    #private;
    constructor(params: {
        ownerDID: string;
        modelID: string;
    });
    get code(): 'KB07';
    get ownerDID(): string;
    get modelID(): string;
}