/**
 * Shadow vaults — `vault.frame()` returns a read-only view of the
 * CURRENT vault state.
 *
 * Companion to {@link VaultInstant} from `history/time-machine.ts`:
 *
 * | Type | Reads from | Use case |
 * |------|------------|----------|
 * | `VaultInstant` | past snapshots (ledger + history) | "books on date X" |
 * | `VaultFrame`   | live vault state                  | screen-share / demo / audit |
 *
 * ```ts
 * const readonly = vault.frame()
 * const invoices = await readonly.collection<Invoice>('invoices').list()
 * await readonly.collection<Invoice>('invoices').put(...)
 * // → throws ReadOnlyFrameError
 * ```
 *
 * ## Contract
 *
 * Every write method on {@link CollectionFrame} throws
 * {@link ReadOnlyFrameError}. Reads delegate to the underlying
 * collection, so validation, locale handling, and caching all work
 * exactly as they do on the live collection.
 *
 * ## Security note: behaviour-enforced, not cryptographically-enforced
 *
 * A VaultFrame rejects writes by contract in the JavaScript layer.
 * It does NOT strip the DEKs from the underlying keyring — the same
 * in-memory keys that decrypt records could, in principle, encrypt
 * new writes via a hand-crafted adapter call. Cryptographic
 * enforcement (keyring variants with the write half of each DEK
 * removed) is hierarchical-access work. Use a VaultFrame to
 * prevent *accidental* writes in a read-scoped flow — do not rely on
 * it as a security boundary against a hostile caller sharing the
 * same process.
 *
 * @module
 */
import type { Collection } from '../../kernel/collection.js';
import type { Query } from '../../kernel/query/builder.js';
import type { Vault } from '../../kernel/vault.js';
import type { LocaleReadOptions } from '../../kernel/types.js';
/**
 * A read-only view of a vault's current state. Produced by
 * `vault.frame()`. Cheap to construct; safe to throw away.
 */
export declare class VaultFrame {
    private readonly vault;
    constructor(vault: Vault);
    /**
     * Get a read-only view of one collection. The returned
     * {@link CollectionFrame} delegates all reads to the underlying
     * live collection — cache, locale handling, and validation all
     * work identically to the live collection.
     */
    collection<T = unknown>(name: string): CollectionFrame<T>;
    /** List all collection names visible in the underlying vault. */
    collections(): Promise<string[]>;
}
/**
 * Read-only collection view. All write methods throw
 * {@link ReadOnlyFrameError}; all read methods delegate to the
 * underlying live {@link Collection}.
 */
export declare class CollectionFrame<T = unknown> {
    private readonly inner;
    /** The underlying collection name. Captured at construction so
     *  we don't need to peek into the private Collection state. */
    readonly name: string;
    constructor(inner: Collection<T>, 
    /** The underlying collection name. Captured at construction so
     *  we don't need to peek into the private Collection state. */
    name: string);
    get(id: string, locale?: LocaleReadOptions): Promise<T | null>;
    list(locale?: LocaleReadOptions): Promise<T[]>;
    /**
     * Return the chainable query builder. Terminals like `.toArray()`,
     * `.first()`, `.count()`, `.aggregate()` all work; the builder has
     * no write surface of its own, so exposing it directly is safe.
     */
    query(): Query<T>;
    query(predicate: (record: T) => boolean): T[];
    /** History reads — allowed (history is read-only by nature). */
    history(...args: Parameters<Collection<T>['history']>): ReturnType<Collection<T>['history']>;
    getVersion(id: string, version: number): Promise<T | null>;
    put(_id: string, _record: T): Promise<never>;
    delete(_id: string): Promise<never>;
    update(_id: string, _patch: Partial<T>): Promise<never>;
    revert(_id: string, _version: number): Promise<never>;
    putMany(_entries: ReadonlyArray<readonly [string, T]>): Promise<never>;
    deleteMany(_ids: readonly string[]): Promise<never>;
}