@pgxsinkit/pgwasm/dist/core/internals.d.ts

/**
 * Wire-level access to a pgwasm instance, kept off its public type. `@pgxsinkit/pgwasm/protocol` and the
 * `live` extension reach it through this registry; pgwasm is bundled with code splitting, so every
 * entry point shares this one module and its map.
 */
import type { BuildCapabilities } from "../build/seam";
import type { BackendMessage, NoticeMessage } from "../protocol/wire/messages";
export interface ExecProtocolOptions {
    /** Persist storage after the message, as a statement does. Defaults to `true`. */
    readonly persist?: boolean;
    /** Throw the first ErrorResponse. Defaults to `true`. */
    readonly throwOnError?: boolean;
    readonly onNotice?: (notice: NoticeMessage) => void;
}
export interface ExecProtocolStreamOptions {
    /** Persist storage after the message. Defaults to `true`. */
    readonly persist?: boolean;
    /** Every backend byte, as it arrives. A chunk is only valid during the call: copy it to keep it. */
    readonly onRawData: (data: Uint8Array) => void;
}
export interface ExecProtocolResult {
    readonly messages: BackendMessage[];
    readonly data: Uint8Array;
}
/** What `protocol(pg)` returns. */
export interface PgwasmProtocol {
    /** Run frontend message bytes; the parsed backend messages and the raw reply. */
    execProtocol(message: Uint8Array, options?: ExecProtocolOptions): Promise<ExecProtocolResult>;
    /** Run frontend message bytes; the parsed backend messages only. */
    execProtocolStream(message: Uint8Array, options?: ExecProtocolOptions): Promise<BackendMessage[]>;
    /** Run frontend message bytes; the raw reply. Notifications and errors are still dispatched. */
    execProtocolRaw(message: Uint8Array, options?: Pick<ExecProtocolOptions, "persist">): Promise<Uint8Array>;
    /**
     * Run frontend message bytes and stream the raw reply. When nothing is pending and the build has
     * `synchronousExchange`, the whole reply is delivered before this call returns its promise — what a
     * tool driving it from inside a blocking wasm callback (pg_dump) needs.
     */
    execProtocolRawStream(message: Uint8Array, options: ExecProtocolStreamOptions): Promise<void>;
    /**
     * Run `fn` with the database's session to itself, for a tool whose exchanges must not interleave with
     * anything else (pg_dump). It waits for, then holds, the locks a `transaction()` holds, and the query
     * lock: no query, exec, transaction, listen, live-query refresh or Store backup of this database runs
     * until `fn` settles.
     *
     * What `fn` sends with the `execProtocol*` methods is its own responsibility: no transaction is begun
     * or ended around it, and a message is persisted only as its options say. Inside `fn`, use only these
     * wire methods: the database's query methods wait for the locks `fn` holds, so awaiting one deadlocks.
     */
    runExclusiveSession<T>(fn: () => Promise<T>): Promise<T>;
    /** The build's capabilities, e.g. to check `synchronousExchange` before relying on it. */
    readonly capabilities: BuildCapabilities;
}
export declare function registerProtocolAccess(pg: object, access: PgwasmProtocol): void;
/** The wire-level access of a pgwasm instance. Throws for anything else. */
export declare function protocolAccessOf(pg: object): PgwasmProtocol;
export declare function registerStrictSync(pg: object, strictSync: () => void): void;
/** The registered strict sync of `pg`, or `undefined` when it has none (not an OPFS-repacked store). */
export declare function strictSyncOf(pg: object): (() => void) | undefined;
//# sourceMappingURL=internals.d.ts.map