@adcp/sdk 16.0.0-beta.2 → 16.0.0-beta.4

package/dist/lib/reporting/ledger/postgres.d.mts

@@ -1,689 +0,0 @@
-import { REPORTING_LEDGER_AUTHORITY } from './types.mjs';
-import type { ReportingLedgerConfigurationV1, ReportingLedgerAdjustmentMetadataV1, ReportingLedgerAdjustmentV1, ReportingLedgerConsumerStatusV1, ReportingLedgerIssueV1, ReportingLedgerLeaseV1, ReportingLedgerObligationV1, ReportingLedgerPageV1, ReportingLedgerRevisionV1, ReportingLedgerSnapshotQueryV1, ReportingLedgerSnapshotV1, ReportingLedgerStatusTransitionV1, ReportingLedgerNotificationActivityPortV1, ReportingLedgerTransactionV1, ReportingObservedFinalityV1, ReportingLedgerStore, ReportingConsumerStatusBatchInputV1, ReportingConsumerStatusBatchResultV1, ReportingConsumerStatusReplayInputV1, ReportingLedgerRevisionMetadataV1, ReportingRevisionRowsPageV1, ReportingRevisionRowsReadV1, ReportingManagedLifecycleProjectionV1, ReportingLedgerAuthorityV1 } from './types.mjs';
-import type { ReportingConsumerMismatchEscalationV1 } from './types.mjs';
-import { type ReportingChangeKindV1, type ReportingChangesPageV1 } from './change-feed.mjs';
-import { type ReportingRowStorageOptionsV1 } from './row-storage.mjs';
-type QueryResultRow = Record<string, unknown>;
-interface ReportingPgResult<Row extends QueryResultRow> {
-    rows: Row[];
-    rowCount: number | null;
-}
-interface ReportingPgClient {
-    query<Row extends QueryResultRow = QueryResultRow>(text: string, values?: unknown[]): Promise<ReportingPgResult<Row>>;
-    release(error?: Error): void;
-}
-/**
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export interface ReportingPgPool {
-    query<Row extends QueryResultRow = QueryResultRow>(text: string, values?: unknown[]): Promise<ReportingPgResult<Row>>;
-    connect(): Promise<ReportingPgClient>;
-}
-/**
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare const REPORTING_LEDGER_MIGRATION: string;
-/**
- * Constraint installed by {@link REPORTING_LEDGER_FINALITY_WRITER_FENCE_MIGRATION}.
- *
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare const REPORTING_LEDGER_FINALITY_FENCE_CONSTRAINT = "adcp_reporting_transitions_finality_recorded";
-/**
- * Cutover migration that fences pre-SDK-14 writers out of the transition log.
- *
- * A pre-SDK-14 writer appends transitions with no `finality`. Each one becomes
- * the latest row, gets its baseline committed as `none`, and can therefore
- * produce another redundant finality-only transition — so "at most one per
- * obligation at upgrade" only holds once no such writer remains. Wall clocks
- * and deploy ordering cannot establish that; a database constraint can.
- *
- * The constraint is added `NOT VALID`, which enforces it for every INSERT and
- * UPDATE while leaving historical rows untouched and unvalidated. Existing
- * finality-less rows keep working — the baseline resolver and
- * `markTransitionNotified` both write `finality` as part of their update, so the
- * new row version satisfies the check.
- *
- * Run it as part of the cutover, **after** legacy writers are drained. A legacy
- * writer that is still running will fail closed on append rather than silently
- * multiply finality-only events, which is the intended trade: loud rejection
- * beats a quietly broken invariant. Idempotent and re-runnable; it takes no lock
- * once installed.
- *
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare const REPORTING_LEDGER_FINALITY_WRITER_FENCE_MIGRATION: string;
-/**
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export interface PostgresReportingLedgerStoreOptions {
-    /** Assert that the supplied PostgreSQL database/schema is isolated to this deployment. */
-    acknowledgeIsolatedDatabase?: boolean;
-    /**
-     * Same advertised escalation commitment passed to
-     * `createReportingStatusHandler`. The store needs it because the `health`
-     * query filter is applied while building the snapshot, before the handler
-     * projects anything — so if the two disagree about when a consumer-status
-     * mismatch escalates, a filtered `periods` read silently omits obligations
-     * the unfiltered read shows.
-     */
-    consumerMismatchEscalation?: ReportingConsumerMismatchEscalationV1;
-    /** Explicitly opt this Core store into projecting the additive #2944 tables. */
-    managedDelivery?: boolean;
-    /**
-     * Supplies the principals that owe a receipt for one obligation.
-     *
-     * Nothing durable in the managed tables enumerates them — destination
-     * authorizations and bindings are keyed by
-     * `(account_id, destination_ref, generation)` with no consumer dimension — so
-     * without this the store can only report who has already submitted, and must
-     * stay conservative: a `consumer_receipt` obligation is then never reported
-     * reconciled on a lifecycle transition. Wire this to whatever your
-     * authorization layer knows and return `complete: true` to get accurate
-     * reconciled transitions and webhooks.
-     *
-     * `complete: true` is taken at your word, and this is the only place in the
-     * subsystem where an adopter assertion can mark billing reconciled: a roster
-     * omitting a principal that owes a receipt makes that duty vanish from the
-     * fold, so the obligation can be persisted and notified reconciled while
-     * that principal never accepted. It is invoked outside the store's
-     * transaction and under a deadline, so it may do I/O — but it must not be
-     * slower than that deadline.
-     */
-    obligatedConsumers?: (input: {
-        reporting_obligation_id: string;
-        account_id: string;
-    }) => Promise<{
-        ids: readonly string[];
-        complete: boolean;
-        version?: string;
-    }>;
-    /**
-     * Durable notification/activity port invoked inside the authoritative
-     * lifecycle transaction. Its tables must be migrated before transitions run.
-     */
-    notificationActivityPort?: ReportingLedgerNotificationActivityPortV1<ReportingLedgerTransactionV1>;
-    /**
-     * Store new revision and adjustment rows as verified canonical JSONL chunks
-     * (see `REPORTING_ROW_STORAGE_MIGRATION`) instead of inline in the ledger
-     * document. `true` uses a single `postgres` binding. Revisions written
-     * before enabling this keep their inline rows; reads handle both forms
-     * whether or not this option is set.
-     */
-    rowStorage?: boolean | ReportingRowStorageOptionsV1;
-    /**
-     * Append obligation, revision, adjustment and retirement changes to the
-     * host change feed (`REPORTING_LEDGER_CHANGES_MIGRATION`, PostgreSQL 13+) in
-     * the same transaction as each record. Required for `changesAfter`.
-     */
-    changeFeed?: boolean;
-}
-/**
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare class ReportingLedgerLeaseLostError extends Error {
-    constructor(message?: string);
-}
-/**
- * A planner or writer named a period whose ledger records were retired by retention.
- *
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare class ReportingLedgerPeriodRetiredError extends Error {
-    constructor(message?: string);
-}
-/**
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare class ReportingLedgerContinuityError extends Error {
-    constructor(message?: string);
-}
-/**
- * Bounded global cleanup for expired cursor snapshots and changes checkpoints.
- *
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare function sweepExpiredReportingLedgerState(pool: Pick<ReportingPgPool, 'query'>, limit?: number): Promise<{
-    snapshotsDeleted: number;
-    checkpointsDeleted: number;
-}>;
-/**
- * @experimental Reliable Reporting storage surface: breaking changes may ship in minor releases. See https://github.com/adcontextprotocol/adcp-client/blob/main/docs/guides/REPORTING-STABILITY.md
- */
-export declare class PostgresReportingLedgerStore implements ReportingLedgerStore {
-    private readonly pool;
-    /**
-     * Exposed so `createReportingStatusHandler` can inherit it and refuse a
-     * disagreement. The store applies `health` while building the snapshot and
-     * the handler projects severity afterwards, so two independently configured
-     * copies of the escalation window would let a filtered periods read
-     * contradict the summary.
-     */
-    readonly consumerMismatchEscalation?: ReportingConsumerMismatchEscalationV1;
-    readonly [REPORTING_LEDGER_AUTHORITY]: ReportingLedgerAuthorityV1;
-    private readonly managedDelivery;
-    private readonly obligatedConsumers;
-    readonly transactionalNotificationActivity: boolean;
-    private readonly notificationActivityPort?;
-    private readonly rowStorage;
-    private readonly rowStorageWrites;
-    private readonly changeFeed;
-    constructor(pool: ReportingPgPool, options?: PostgresReportingLedgerStoreOptions);
-    /** Whether this store writes the host change feed (`changeFeed: true`). */
-    get changeFeedEnabled(): boolean;
-    /**
-     * Delete expired cursor snapshots and changes checkpoints, a bounded batch
-     * at a time. The store-bound form of `sweepExpiredReportingLedgerState`, for
-     * hosts that hold the store but not the pool.
-     */
-    sweepExpiredState(limit?: number): Promise<{
-        snapshotsDeleted: number;
-        checkpointsDeleted: number;
-    }>;
-    /** Append one host change-feed row inside the caller's account-locked transaction. */
-    private appendChange;
-    /**
-     * Defense in depth for snapshot compaction (see `compactSupersededSnapshots`): throws `INVALID_INPUT`
-     * if a writable object row binding's key template omits `{revision_key}`. Every such binding is
-     * already refused when the store is configured, so this only guards a configuration changed after
-     * construction; `readOnly` bindings are skipped. Called by `compactSupersededSnapshots` and by
-     * service construction when compaction is enabled.
-     */
-    assertCompactionSafeRowBindings(): void;
-    /** Probe and register row storage when enabled. Safe to call repeatedly. */
-    readyRowStorage(): Promise<void>;
-    /**
-     * Move legacy inline revision and adjustment rows into row storage, a
-     * bounded batch at a time. Each row set is re-encoded, proven to reproduce
-     * its committed binding, written, and only then removed from the ledger
-     * document, in one transaction under the account lock. A document whose
-     * rows do not reproduce its binding is never rewritten: it is reported in
-     * `quarantined` and left inline. Pass the returned `cursor` back to resume
-     * after the last examined document; it is absent once every candidate has
-     * been examined. Reclaiming the freed space needs `VACUUM FULL` or an online
-     * repack.
-     */
-    migrateInlineRows(input?: {
-        limit?: number;
-        account_id?: string;
-        cursor?: string;
-        bindingId?: string;
-        signal?: AbortSignal;
-    }): Promise<{
-        migrated: number;
-        quarantined: string[];
-        cursor?: string;
-    }>;
-    putConfiguration(configuration: ReportingLedgerConfigurationV1): Promise<{
-        inserted: boolean;
-        value: ReportingLedgerConfigurationV1;
-    }>;
-    listConfigurations(account_id?: string): Promise<ReportingLedgerConfigurationV1[]>;
-    putObligation(obligation: ReportingLedgerObligationV1): Promise<{
-        inserted: boolean;
-        value: ReportingLedgerObligationV1;
-    }>;
-    getObligation(id: string, account_id?: string): Promise<ReportingLedgerObligationV1 | null>;
-    /** Periods retired by retention; planners treat them as already covered. */
-    listRetiredObligationOrdinals(account_id?: string): Promise<{
-        configurationId: string;
-        periodOrdinal: number;
-    }[]>;
-    listObligations(account_id?: string): Promise<ReportingLedgerObligationV1[]>;
-    listLifecycleDueObligations(input: {
-        ledgerAsOf: string;
-        account_id?: string;
-        limit: number;
-    }): Promise<ReportingLedgerObligationV1[]>;
-    updateObligation(obligation: ReportingLedgerObligationV1, lease: ReportingLedgerLeaseV1, issue?: ReportingLedgerIssueV1): Promise<void>;
-    claimObligation(input: {
-        owner: string;
-        now: string;
-        leaseMilliseconds: number;
-        account_id?: string;
-    }): Promise<ReportingLedgerLeaseV1 | null>;
-    releaseObligationLease(lease: ReportingLedgerLeaseV1): Promise<void>;
-    commitRevision(revision: ReportingLedgerRevisionV1, lease: ReportingLedgerLeaseV1): Promise<{
-        inserted: boolean;
-        value: ReportingLedgerRevisionV1;
-    }>;
-    getRevision(id: string, accountId: string): Promise<ReportingLedgerRevisionV1 | null>;
-    getRevisionMetadata(id: string, accountId: string): Promise<ReportingLedgerRevisionMetadataV1 | null>;
-    readRevisionRows(input: ReportingRevisionRowsReadV1): Promise<ReportingRevisionRowsPageV1 | null>;
-    listRevisions(obligationId: string): Promise<ReportingLedgerRevisionV1[]>;
-    listRevisionMetadata(obligationId: string, accountId?: string): Promise<ReportingLedgerRevisionMetadataV1[]>;
-    commitAdjustment(adjustment: ReportingLedgerAdjustmentV1, lease: ReportingLedgerLeaseV1): Promise<{
-        inserted: boolean;
-        value: ReportingLedgerAdjustmentV1;
-    }>;
-    listAdjustments(obligationId: string): Promise<ReportingLedgerAdjustmentV1[]>;
-    /**
-     * The obligation's current revision header: its official revision if one
-     * exists, otherwise its highest-numbered snapshot. An official revision is
-     * terminal, so this is always the highest revision number — one index
-     * lookup. Rows are read separately through `readRevisionRows`.
-     */
-    getCurrentRevision(input: {
-        account_id: string;
-        reporting_obligation_id: string;
-    }): Promise<ReportingLedgerRevisionMetadataV1 | null>;
-    /**
-     * Current revision headers for an account's obligations whose period starts
-     * in `[period_start_from, period_start_to)`, ordered by period start.
-     * Obligations without a revision yet are omitted. Page with `cursor`.
-     */
-    listCurrentRevisions(input: {
-        account_id: string;
-        period_start_from: string;
-        period_start_to: string;
-        delivery_config_id?: string;
-        limit?: number;
-        cursor?: string;
-    }): Promise<{
-        revisions: ReportingLedgerRevisionMetadataV1[];
-        cursor?: string;
-    }>;
-    /**
-     * Host change feed. Omit `cursor` to start from the oldest retained change.
-     * Account-scoped feeds order by sequence; the deployment-wide feed orders by
-     * `(xid, seq)` and returns only changes whose transaction precedes every
-     * transaction still in flight, so no commit is ever skipped. An account page
-     * also ends before the first change whose transaction has not finished, as
-     * defense in depth against a change that commits late. An empty page can
-     * therefore mean either caught up or held back by an older open transaction.
-     * A ledger database must have exactly one writer SDK; see
-     * `docs/guides/REPORTING-LEDGER.md`. A cursor older
-     * than the retained history throws `ReportingChangeCursorExpiredError`;
-     * resynchronize from `listCurrentRevisions`.
-     *
-     * A read without a `cursor` can throw `ReportingChangeCursorExpiredError`
-     * (`code === 'CURSOR_EXPIRED'`) too. The horizon is re-read after the page,
-     * so a prune that commits mid-read rejects the page instead of returning one
-     * that silently skips the pruned changes. Retrying the read starts from the
-     * new, later horizon. Match on `error.code` rather than `instanceof`, which
-     * fails when the error crosses a CJS/ESM module boundary.
-     */
-    changesAfter(input?: {
-        cursor?: string;
-        account_id?: string;
-        kinds?: readonly ReportingChangeKindV1[];
-        limit?: number;
-    }): Promise<ReportingChangesPageV1>;
-    /**
-     * Record a named durable consumer's position. Registered consumers hold
-     * back change-table pruning until `maxFeedHoldDays` after their last update.
-     *
-     * Checkpoints are forward-only within a feed scope: a cursor behind the
-     * saved one is ignored, so a delayed or stale acknowledgment cannot pull the
-     * retention hold back. Resolves `true` when the checkpoint was written and
-     * `false` when it was ignored (behind the saved position, or equal with
-     * `refreshUnchanged: false`). To rewind a consumer deliberately, for example
-     * to replay changes, pass `rewind: true`; the saved position and retention
-     * hold then move to `cursor` and the write always applies, even with
-     * `refreshUnchanged: false`. The cursor is not checked against the
-     * retention horizon: it must still be inside the retained history or the
-     * next read throws `ReportingChangeCursorExpiredError`. Any change of
-     * `account_id` (account to deployment, deployment to account, or between
-     * accounts) always replaces the position. The feed scope is read from the
-     * cursor itself, so only pass cursors your own code obtained from
-     * `changesAfter`, never ones supplied by an untrusted caller.
-     *
-     * Set `refreshUnchanged: false` to recover an acknowledgment without
-     * renewing the retention hold when its position has not advanced.
-     */
-    saveFeedConsumerCursor(name: string, cursor: string, options?: {
-        refreshUnchanged?: boolean;
-        rewind?: boolean;
-    }): Promise<boolean>;
-    /**
-     * Unregister a durable consumer so it stops holding back change-table
-     * pruning and period retention. Resolves `true` when a registration was
-     * removed. Saving a cursor under the same name registers it again.
-     */
-    removeFeedConsumer(name: string): Promise<boolean>;
-    /**
-     * Delete change rows older than `changeRetentionDays` that every consumer
-     * updated within `maxFeedHoldDays` has passed, and advance the expiry
-     * horizon so older cursors fail closed.
-     */
-    pruneChanges(input?: {
-        changeRetentionDays?: number;
-        maxFeedHoldDays?: number;
-        limit?: number;
-    }): Promise<{
-        deleted: number;
-    }>;
-    /**
-     * Retire whole reporting periods whose retention has elapsed (shared SDK
-     * persistence spec §4). A period is eligible once both its end and its
-     * latest publication are older than `max(statusRetentionDays,
-     * recordRetentionDays)`, no worker holds its lease, and no Managed Delivery
-     * materialization still references it. Retirement is period-aligned and
-     * resumable:
-     *
-     * 1. under the account lock, record a `retiring` tombstone and mark the
-     *    period's row sets `pruning`, so exact reads answer as expired;
-     * 2. delete the period's external row objects at their recorded versions;
-     * 3. under the account lock, delete the period's ledger records (rows,
-     *    revisions, adjustments, consumer statuses, issues, transitions,
-     *    lifecycle state, obligation) and mark the tombstone `retired`.
-     *
-     * Planners skip retired periods, and `ledger_retained_from` advances past
-     * them because their obligations no longer exist.
-     *
-     * When the change-feed tables exist, a period that is not yet retiring is
-     * also held while any live registered feed consumer (updated within
-     * `maxFeedHoldDays`, default 7) has not passed that period's change rows in
-     * the consumer's own feed order, the same rule `pruneChanges` applies. A
-     * held period is simply not a candidate this pass. A consumer that stays
-     * silent past `maxFeedHoldDays` stops holding, so retention is never
-     * blocked forever; it then falls behind retention and a sink sees the
-     * retired revisions as missing.
-     */
-    retireExpiredPeriods(input: {
-        statusRetentionDays: number;
-        recordRetentionDays?: number;
-        maxFeedHoldDays?: number;
-        limit?: number;
-        account_id?: string;
-        signal?: AbortSignal;
-    }): Promise<{
-        retired: number;
-        failed: string[];
-        /** Secret-free cause per period that failed this pass: a row-store code or the error class name. */
-        failures: {
-            reporting_obligation_id: string;
-            cause: string;
-        }[];
-        /** Retiring periods currently backing off after a failure; they are not attempted this pass. */
-        deferred: number;
-        /**
-         * Periods that have failed at least five attempts and
-         * are still retiring (at most 20, worst first). They need operator attention, for example a
-         * removed binding or a permanent provider error.
-         */
-        stuck: {
-            reporting_obligation_id: string;
-            attempts: number;
-            cause: string;
-        }[];
-    }>;
-    /**
-     * Record a failed retirement attempt on the period's tombstone and push its next
-     * attempt out by an exponential backoff. Best effort: a failure to record only
-     * means the period is retried on the next pass.
-     */
-    private recordRetirementFailure;
-    private retirePeriod;
-    /**
-     * Compact superseded snapshot revisions to metadata only, as adcontextprotocol/adcp#8100
-     * permits (`reporting-revision.json` `content_retention`). Opt-in: nothing calls this
-     * unless the host enables `compaction` in maintenance, and it must not be enabled in
-     * production before the AdCP release that takes compaction into effect (the next
-     * eligible minor after November 20, 2026).
-     *
-     * A snapshot revision is compacted only when every one of these holds:
-     *
-     * - it is superseded: a later revision names it in `supersedes_reporting_revision_id`
-     *   (so a current revision, and every official revision, is never compacted);
-     * - it is not the revision the current, unsuperseded revision names;
-     * - its recovery grace has passed: `max(automatedRecoveryWindowSeconds, 3600)` seconds
-     *   since its successor's `created_at`;
-     * - while its window is open (`statusRetentionDays` since its successor's `created_at`),
-     *   no caller's reporting receipt (any status) names it and no caller's current consumer
-     *   status statement of `received`, `unreadable` or `content_mismatch` names it. The
-     *   check spans every caller, so content any caller is entitled to is kept;
-     * - it has rows (nothing to reclaim otherwise, and an empty exact read is still correct);
-     * - no live obligation lease, no pending materialization of it, and no live change-feed
-     *   consumer that has not yet passed its change row (the holds retirement applies,
-     *   narrowed to this revision).
-     *
-     * Only row content is dropped: the revision header, its manifest and every metadata
-     * listing stay. The row set is marked `pruned`, so an exact read answers
-     * `ROWS_EXPIRED`, which the handlers surface as the same nondisclosing
-     * `REFERENCE_NOT_FOUND` as an unknown ID. No change-feed row is recorded: the revision's
-     * metadata is unchanged, and a sink still catching up holds compaction back.
-     *
-     * Compaction is resumable and runs in the same three phases as retirement, under the
-     * account lock where eligibility is decided:
-     *
-     * 1. re-check eligibility and mark the row set `pruning`, so reads answer as expired and
-     *    no new revision can share its chunks;
-     * 2. delete external objects at their recorded versions, skipping any object another
-     *    row set that is not being pruned still references (chunk sharing);
-     * 3. delete the chunk manifest rows and any PostgreSQL chunk body nothing else
-     *    references, and mark the row set `pruned`.
-     *
-     * A crash after phase 1 leaves a `pruning` row set that the next pass resumes.
-     */
-    compactSupersededSnapshots(input: {
-        statusRetentionDays: number;
-        automatedRecoveryWindowSeconds: number;
-        maxFeedHoldDays?: number;
-        limit?: number;
-        account_id?: string;
-        signal?: AbortSignal;
-    }): Promise<{
-        compacted: number;
-        failed: string[];
-        /** Secret-free cause per failed revision: a row-store code or the error class name. */
-        failures: {
-            reporting_obligation_id: string;
-            reporting_revision_id: string;
-            cause: string;
-        }[];
-    }>;
-    private compactSnapshot;
-    /**
-     * Resolve abandoned object uploads (spec §4.3). An expired `open` write
-     * intent whose ledger commit never happened is moved to `sweeping` under
-     * the account lock, so no writer can commit against it, then only the
-     * objects that upload created — never adopted ones, never any object a
-     * committed chunk references — are deleted at their recorded versions.
-     * Interrupted sweeps resume.
-     */
-    sweepRowWriteIntents(input?: {
-        limit?: number;
-        account_id?: string;
-        overdueAfterSeconds?: number;
-        signal?: AbortSignal;
-    }): Promise<{
-        swept: number;
-        objectsDeleted: number;
-        /** Intents whose sweep failed this pass. Each backs off before its next attempt. */
-        failed: number;
-        /**
-         * Expired intents with objects to delete through a binding this host does not configure. They
-         * are left untouched for a host that configures it; they are not failures of this host.
-         */
-        skippedUnconfigured: number;
-        /** Expired intents backing off after a failed sweep, not attempted this pass. */
-        deferred: number;
-        /**
-         * Intents expired for longer than `overdueAfterSeconds` (default 24 hours) and still not swept,
-         * including ones backing off. Their objects are leaking: check that a host configures their
-         * binding and that provider deletes succeed.
-         */
-        overdue: number;
-    }>;
-    /**
-     * Delete external row objects, skipping any object another row set still references.
-     *
-     * Object keys are unique per row set (every writable template includes `{revision_key}`), but header-only
-     * revisions share chunks within an obligation and rows written under an older template can name one
-     * object from several row sets. An object is therefore deleted only when no
-     * chunk of a live (or unavailable) row set outside this operation references the same binding,
-     * key and native version, and no other open write intent created it. Row sets already `pruning`
-     * or `pruned` do not count: their own operation deletes the object, and counting them would let
-     * two concurrent retirements each skip the object and leak it. `scope` names what this
-     * operation is deleting: an obligation (retirement) or a row set (compaction).
-     *
-     * The check and the provider delete run in one transaction under a per-object advisory lock.
-     * A commit that adopts an existing object takes the same lock before it inserts its chunk rows
-     * and re-verifies the object under it (`writePreparedRowSet`), and holds it until commit. So
-     * either the delete wins the lock and the adopting commit then fails cleanly, or the commit wins
-     * and the delete sees its chunk rows and skips. A skipped object stays for the row set that owns
-     * it: that row set's own retirement, compaction or sweep deletes it, because by then nothing
-     * else references it. Locks are taken one object at a time, never while waiting on the account
-     * lock, so commits (account lock, then object locks) cannot deadlock with these deletes.
-     */
-    private deleteUnreferencedObjects;
-    private optionalTables;
-    /**
-     * Upload an object-kind row set before its ledger commit (spec §3.5):
-     * skip when the document already exists (replay), refuse unless the lease
-     * still covers the upload deadline, open or take over an expired write
-     * intent under the account lock, then write every chunk create-only,
-     * recording each object this upload created in the intent first.
-     */
-    private uploadRowSetUnlessCommitted;
-    /** Persist a prepared row set and close its upload intent in the ledger commit transaction. */
-    private writePreparedRowSet;
-    /** Attach verified rows to a revision document whose rows live in row storage. */
-    private hydrateRevision;
-    listAdjustmentMetadata(obligationId: string): Promise<ReportingLedgerAdjustmentMetadataV1[]>;
-    putConsumerStatus(status: ReportingLedgerConsumerStatusV1): Promise<{
-        inserted: boolean;
-        value: ReportingLedgerConsumerStatusV1;
-    }>;
-    getConsumerStatusBatchReplay(input: ReportingConsumerStatusReplayInputV1): Promise<ReportingConsumerStatusBatchResultV1[] | null>;
-    syncConsumerStatusBatch(input: ReportingConsumerStatusBatchInputV1): Promise<ReportingConsumerStatusBatchResultV1[]>;
-    listConsumerStatuses(revisionId: string): Promise<ReportingLedgerConsumerStatusV1[]>;
-    putIssue(issue: ReportingLedgerIssueV1): Promise<void>;
-    resolveIssue(issueId: string, resolvedAt: string): Promise<void>;
-    listIssues(obligationId: string): Promise<ReportingLedgerIssueV1[]>;
-    /**
-     * Resolves — and for pre-SDK-14 rows persists — the observed finality baseline
-     * of the obligation's latest transition, so the lifecycle decision and this
-     * store's compare-and-set read one committed value.
-     */
-    resolveTransitionFinalityBaseline(obligationId: string): Promise<ReportingObservedFinalityV1>;
-    appendTransition(transition: ReportingLedgerStatusTransitionV1): Promise<{
-        inserted: boolean;
-    }>;
-    private appendTransitionWithinLock;
-    applyLifecycleProjection(input: {
-        reporting_obligation_id: string;
-        expectedRevisionIds: string[];
-        expectedPreviousHealth: import('./types.mjs').ReportingHealthV1;
-        expectedPreviousFinality?: ReportingObservedFinalityV1;
-        expectedObligationState: ReportingLedgerObligationV1['state'];
-        expectedAttemptCount: number;
-        projectedIssues: ReportingLedgerIssueV1[];
-        ledgerAsOf: string;
-        transition?: ReportingLedgerStatusTransitionV1;
-        expectedManagedStateVersion?: string;
-        processedManagedStateVersion?: string;
-        processedObligatedConsumerRosterVersion?: string;
-        expectedObligatedConsumerRosterVersion?: string;
-    }): Promise<{
-        applied: boolean;
-        transitionInserted: boolean;
-    }>;
-    private applyLifecycleProjectionWithinLock;
-    markTransitionNotified(transitionId: string, notifiedAt: string): Promise<void>;
-    listTransitions(obligationId: string): Promise<ReportingLedgerStatusTransitionV1[]>;
-    listPendingTransitions(input?: {
-        account_id?: string;
-        limit?: number;
-    }): Promise<ReportingLedgerStatusTransitionV1[]>;
-    createSnapshot(query: ReportingLedgerSnapshotQueryV1): Promise<ReportingLedgerSnapshotV1>;
-    readSnapshotPage(snapshotId: string, account_id: string, cursor: string | undefined, limit: number): Promise<ReportingLedgerPageV1>;
-    private listSnapshotConsumerStatuses;
-    private listSnapshotObligations;
-    private listSnapshotConfigurations;
-    private resolveChangesCheckpoint;
-    private listSnapshotRevisions;
-    private listSnapshotIssues;
-    private listSnapshotAdjustments;
-    /**
-     * Managed Delivery projection inputs for one obligation, grouped per consumer.
-     *
-     * The lifecycle reconciler folds these through the same
-     * `projectManagedDelivery` the read path uses, so a persisted transition and
-     * its webhook report the health a read of the same obligation would return.
-     * Returns `null` when Managed Delivery is not installed or the obligation's
-     * configuration has no binding, which keeps a Core-only ledger unchanged.
-     */
-    getManagedLifecycleProjection(input: {
-        reporting_obligation_id: string;
-        ledgerAsOf?: string;
-    }): Promise<ReportingManagedLifecycleProjectionV1 | null>;
-    /**
-     * Digest over every managed row that can change this obligation's projected
-     * health: materialization status, receipt existence and current-leaf flag,
-     * adjustments, and the destination authorization's revocation/cleanup state.
-     *
-     * `is_current` is included because superseding a receipt flips it with no
-     * timestamp of its own, and the authorization's `cleanup_completed_at` is
-     * included because `completeRevocation` does not touch `changed_at`.
-     */
-    private readManagedStateVersion;
-    /**
-     * Current external roster version, read outside any transaction so the
-     * reconciler can re-check it immediately before an apply.
-     */
-    /**
-     * Publishes the roster version currently observed for an obligation.
-     *
-     * The roster is external, so nothing in this database changes when it does.
-     * Recording what a reader saw is what lets the due query notice drift from
-     * the version last reconciled. Never lowers a watermark; it only reports.
-     */
-    recordObligatedConsumerRosterVersion(input: {
-        reporting_obligation_id: string;
-        version: string;
-    }): Promise<void>;
-    /**
-     * Re-reads the external roster for managed obligations and publishes what
-     * it saw, so a change made while nothing was scheduled can re-arm.
-     *
-     * Ordered by least-recently-refreshed and bounded, so a large account is
-     * swept over successive passes rather than in one burst of callbacks.
-     */
-    refreshObligatedConsumerRosterVersions(input: {
-        account_id?: string;
-        limit: number;
-    }): Promise<number>;
-    /**
-     * Records a failed reconcile so the obligation backs off instead of
-     * re-occupying the head of every sweep, without ever hiding it: the
-     * watermark is untouched, so it stays unresolved work.
-     */
-    recordLifecycleFailure(input: {
-        reporting_obligation_id: string;
-    }): Promise<void>;
-    /** Authoritative instant from the database clock, at microsecond precision. */
-    readLedgerInstant(): Promise<string>;
-    readObligatedConsumerRosterVersion(input: {
-        reporting_obligation_id: string;
-    }): Promise<string | undefined>;
-    /** Principals that have engaged with this obligation, as the projection sees them. */
-    private observedConsumerIds;
-    private managedDueTablesReadyCache;
-    /** Whether the managed schema exists, resolved once per store instance. */
-    private managedDueTablesReady;
-    /**
-     * Terminal receipt subjects whose bodies have been pruned.
-     *
-     * The projection decides reconciliation from the receipt rows it can see,
-     * so once an accepted leaf ages out the subject looks unreconciled again
-     * and a settled billing period reopens. The tombstone is the only remaining
-     * proof, so the projection has to consult it.
-     */
-    private listTombstonedAcceptedSubjects;
-    private managedTablesInstalled;
-    private listManagedChangedObligationIds;
-    private listSnapshotManagedBindings;
-    private listSnapshotMaterializations;
-    private listSnapshotMaterializationProjection;
-    private listSnapshotReceipts;
-    private one;
-    private putImmutable;
-    private accountLockForObligation;
-    private accountLockForIssue;
-    private accountLockForTransition;
-    private transaction;
-    private query;
-}
-export {};