@abloatai/ablo 0.34.0 → 0.35.0

package/dist/transaction/coordination/schema.d.ts

@@ -0,0 +1,1473 @@
+import { z } from 'zod';
+import type { ParticipantKind } from '../types/participant.js';
+/**
+ * The wire schemas for coordination — the shapes that keep agents and people
+ * from overwriting each other on a shared row. Coordination works in three
+ * layers, from outermost to innermost:
+ *
+ *   1. Presence (observation): who is working where. It reports, never blocks.
+ *   2. Claims (pessimistic leases): `claim_begin` / `claim_abandon` grant one
+ *      participant exclusive intent on a target while others wait.
+ *   3. Stale-context (optimistic): a `readAt` watermark plus an `onStale` write
+ *      guard that catches a lost update when the row moved after you read it.
+ *
+ * These Zod schemas are the single definition of each shape. Both the client
+ * SDK and the server derive their TypeScript types from them with `z.infer`
+ * rather than re-declaring the shapes, and the server validates inbound frames
+ * against them at runtime.
+ */
+/** A line/column span within a text-bearing field (section body, doc, cell). */
+export declare const targetRangeSchema: z.ZodObject<{
+    startLine: z.ZodNumber;
+    endLine: z.ZodNumber;
+    startColumn: z.ZodOptional<z.ZodNumber>;
+    endColumn: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TargetRange = z.infer<typeof targetRangeSchema>;
+export declare const participantKindSchema: z.ZodEnum<{
+    user: "user";
+    agent: "agent";
+    system: "system";
+}>;
+export type { ParticipantKind } from '../types/participant.js';
+/**
+ * Parses a participant kind from an inbound frame, tolerating an older wire
+ * dialect. Some presence and claim frames label a non-agent participant
+ * `'human'`, while the rest of the surface uses `'user'` for the same
+ * participant. This normalizes `'human'` to `'user'` on read so every consumer
+ * switches on one vocabulary. Producers emit the canonical
+ * {@link participantKindSchema} values, and the output union is never widened.
+ */
+export declare const wireParticipantKindSchema: z.ZodPreprocess<z.ZodEnum<{
+    user: "user";
+    agent: "agent";
+    system: "system";
+}>>;
+/**
+ * Resolves a peer's kind from an inbound presence or claim frame. It prefers
+ * the server-stamped `participantKind` (normalized through
+ * {@link wireParticipantKindSchema}). A frame from an older server that omits
+ * that field falls back to the `isAgent` boolean, which can tell 'agent' from
+ * 'user' but can never report 'system'.
+ */
+export declare function participantKindFromWire(wireKind: unknown, isAgent: boolean | undefined): ParticipantKind;
+/**
+ * Reads the peer-visible description a claim or presence frame carries in its
+ * opaque `meta.description`. This is the single place that unpacks that field.
+ * A caller that has an explicit `description` should prefer it
+ * (`explicit ?? fromMeta`).
+ *
+ * The parameter is `unknown` because that is the honest requirement: this reads
+ * one optional string off a value it does not own. Demanding the wire's open
+ * record instead forced every caller holding a claim's *declared* `meta` — the
+ * shape registered on `Register`'s `ClaimMeta` slot — through a conversion to
+ * ask a question that never needed one.
+ */
+export declare function descriptionFromMeta(meta: unknown): string | undefined;
+/** The default a claim carries when its holder describes no work. */
+export declare const DEFAULT_CLAIM_DESCRIPTION = "editing";
+/**
+ * Resolves the peer-visible description of a claim from the places a caller may
+ * have put it, falling back to a plain default.
+ *
+ * `reason` was this field's name before it was renamed, and the rename shipped
+ * without leaving anything behind — so the wire kept accepting both spellings
+ * while the SDK type quietly offered only one, and two branches "fixed" the
+ * gap in opposite directions without either being contradicted by a compiler.
+ * The precedence is declared once, here, and both the client and the server
+ * read it from this function rather than each spelling out the same `??` chain.
+ *
+ * A caller whose default differs — a claim taken around a `create` describes
+ * itself as `'creating'` — passes that word as `fallback`; the precedence above
+ * it stays this function's.
+ */
+export declare function claimDescription(source: {
+    description?: string | null;
+    reason?: string | null;
+    /** Wire-shaped or declared — see {@link descriptionFromMeta}. */
+    meta?: unknown;
+}, fallback?: string): string;
+/**
+ * What a coordination event points at — the locator shared by all three
+ * layers. It names an entity, optionally narrowed to a path, range, or field,
+ * and carries opaque application metadata.
+ */
+export declare const targetRefSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        startColumn: z.ZodOptional<z.ZodNumber>;
+        endColumn: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    field: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TargetRef = z.infer<typeof targetRefSchema>;
+/**
+ * How the server treats a write whose snapshot watermark (`readAt`) is older
+ * than the target row's latest change. There are three dispositions:
+ *   • `notify`    — hold the write and return a {@link StaleNotification}
+ *                   carrying the current value, so the actor (agent or human)
+ *                   can resolve it.
+ *   • `reject`    — throw `AbloStaleContextError`, the default when `readAt`
+ *                   is present.
+ *   • `overwrite` — apply the write blindly, last write wins, with no signal.
+ */
+export declare const onStaleModeSchema: z.ZodEnum<{
+    reject: "reject";
+    overwrite: "overwrite";
+    notify: "notify";
+}>;
+export type OnStaleMode = z.infer<typeof onStaleModeSchema>;
+/**
+ * The optimistic guard carried on a commit operation. `readAt` is the
+ * snapshot watermark from `context.capture` (null/absent ⇒ unguarded write).
+ * `bypass` is the explicit, recorded override of a *foreign* pessimistic
+ * claim — see the claim layer below.
+ */
+export declare const writeGuardSchema: z.ZodObject<{
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    bypass: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type WriteGuard = z.infer<typeof writeGuardSchema>;
+/**
+ * The advisory returned to a committer whose write hit a stale-context
+ * conflict under `onStale: 'notify'` — it reports that the value the committer
+ * reasoned against changed while they were away. Rather than throwing, the
+ * server hands back the conflicting field's current value as data so the
+ * actor — an agent or a human — can reconcile and re-commit. A claim is the
+ * prospective form of the same idea (coordinate before acting); this
+ * notification is the in-flight form (here is what changed, you resolve). It
+ * rides on the commit acknowledgement alongside `lastSyncId`; an empty or
+ * absent array means nothing the committer depended on moved.
+ *
+ * Only `onStale: 'notify'` produces this. The conflicting operation was held,
+ * not written, and the actor reconciles against `currentValues` and
+ * re-commits. `reject` throws instead, and `overwrite` proceeds silently —
+ * neither notifies.
+ */
+export declare const staleNotificationSchema: z.ZodObject<{
+    object: z.ZodOptional<z.ZodLiteral<"stale_notification">>;
+    model: z.ZodString;
+    id: z.ZodString;
+    readAt: z.ZodNumber;
+    observedSyncId: z.ZodNumber;
+    conflictingFields: z.ZodArray<z.ZodString>;
+    currentValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    writtenBy: z.ZodObject<{
+        kind: z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    group: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type StaleNotification = z.infer<typeof staleNotificationSchema>;
+/**
+ * One entry in a commit's batch premise — a read it was based on, so the
+ * server can ask "did anything I looked at change?" — broader than the
+ * write-target check, which only validates the rows being written. The server
+ * re-runs stale detection against each entry at its `readAt`; a moved premise
+ * fires the entry's `onStale` disposition (default `reject`) across the whole
+ * batch (`notify` holds every write and notifies, `reject` aborts, `overwrite`
+ * proceeds silently). An entry comes at one of two granularities:
+ *
+ *   • Row   — `{ model, id, readAt, fields? }`: did this specific row, or these
+ *             specific fields, change?
+ *   • Group — `{ group, readAt }`: did anything in this sync group change?
+ *             `group` is a sync-group key such as `report:abc` or `section:s1`, the
+ *             same unit a participant watches and claims.
+ *
+ * See `packages/sync-engine/docs/concurrency-convention.md` (§4) for the
+ * governing convention and the receive → reconcile loop.
+ */
+export declare const readDependencySchema: z.ZodUnion<readonly [z.ZodObject<{
+    model: z.ZodString;
+    id: z.ZodString;
+    readAt: z.ZodNumber;
+    fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    onStale: z.ZodOptional<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    group: z.ZodString;
+    readAt: z.ZodNumber;
+    onStale: z.ZodOptional<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>;
+}, z.core.$strip>]>;
+export type ReadDependency = z.infer<typeof readDependencySchema>;
+/**
+ * A durable premise — what a participant is watching so that a later
+ * change to it opens a {@link StaleNotification}. It is the persisted sibling of
+ * a {@link ReadDependency}: the same reference shape, minus the disposition (a
+ * track always notifies — that is what tracking is), with an optional `readAt`
+ * that defaults to the watermark of the commit that registered it. The row form
+ * watches one object; the group form watches a whole sync group ("anything in
+ * `report:abc`"). Where a `ReadDependency` is checked once at commit and
+ * discarded, a `TrackDependency` is kept and re-checked against every future
+ * delta. See `packages/sync-engine/docs/groups.md` for how it drives change
+ * propagation.
+ */
+export declare const trackDependencySchema: z.ZodUnion<readonly [z.ZodObject<{
+    model: z.ZodString;
+    id: z.ZodString;
+    readAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    group: z.ZodString;
+    readAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+export type TrackDependency = z.infer<typeof trackDependencySchema>;
+/**
+ * The lifecycle of a claim. When absent on the wire it means `'active'` (an
+ * additive back-compat default). The server stamps `'active'` on `claim_begin`
+ * and emits one terminal frame — `committed`, `canceled`, or `expired` — as the
+ * claim ends, so contenders learn how it resolved, not merely that it vanished.
+ */
+export declare const wireClaimStatusSchema: z.ZodEnum<{
+    active: "active";
+    committed: "committed";
+    expired: "expired";
+    canceled: "canceled";
+}>;
+export type WireClaimStatus = z.infer<typeof wireClaimStatusSchema>;
+/**
+ * Every lifecycle state of a claim, as a caller sees it.
+ *
+ * `active` is the current holder — the lock itself. `queued` is waiting in line
+ * behind the holder and carries an advisory `position`. The rest are terminal
+ * and drop the claim from the synced set.
+ *
+ * Distinct from {@link wireClaimStatusSchema}, which never carries `queued`
+ * because the wire frame for a waiter is a different message. This is the one a
+ * published contract describes, so it is a schema rather than a bare TS union —
+ * a union cannot be derived into the API reference.
+ */
+export declare const publicClaimStatusSchema: z.ZodEnum<{
+    active: "active";
+    committed: "committed";
+    expired: "expired";
+    canceled: "canceled";
+    queued: "queued";
+}>;
+export type PublicClaimStatus = z.infer<typeof publicClaimStatusSchema>;
+/**
+ * @deprecated Renamed to {@link wireClaimStatusSchema} — this is the wire enum,
+ * which never carries `'queued'`; the five-state public status lives in
+ * types/streams. Removed in 0.36.0.
+ */
+export declare const claimStatusSchema: z.ZodEnum<{
+    active: "active";
+    committed: "committed";
+    expired: "expired";
+    canceled: "canceled";
+}>;
+/** @deprecated Renamed to {@link WireClaimStatus}. Removed in 0.36.0. */
+export type ClaimStatus = WireClaimStatus;
+/**
+ * A holder as the participant blocked behind them sees it: who has the row,
+ * what they said they are doing, and until when.
+ *
+ * This is the smaller half of a claim, so it is declared first and the full
+ * claim extends it — the waiter's view cannot omit a member the holder's view
+ * has, because there is nowhere for it to be omitted. Listing what to keep was
+ * the bug: this named `field` and not `path`, `range`, or `fields`, so a waiter
+ * could see that a row was held but never which part of it, and every locator
+ * member added later would have been missing here too.
+ */
+export declare const wireClaimSummarySchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        startColumn: z.ZodOptional<z.ZodNumber>;
+        endColumn: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    field: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    claimId: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    declaredAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+    onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>>;
+    capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type WireClaimSummary = z.infer<typeof wireClaimSummarySchema>;
+/** Why a claim ended in a non-success terminal state. */
+export declare const claimErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    heldBy: z.ZodOptional<z.ZodString>;
+    heldByClaimId: z.ZodOptional<z.ZodString>;
+    heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
+    heldByClaim: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        claimId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        declaredAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>>>>;
+        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    policyReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClaimError = z.infer<typeof claimErrorSchema>;
+/**
+ * A declared, pending-mutation claim — the unit broadcast inside a presence
+ * frame's `activeClaims`. The client supplies the descriptive `targetRef`
+ * fields, a `description` of the work, and a chosen `claimId`; the server stamps
+ * `declaredAt` and `expiresAt` and may set `status` and `error`. Those last
+ * two are optional, so one shape serves both the server, which sets them, and
+ * the leaner SDK view, which reads a claim without them.
+ */
+export declare const wireClaimSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        startColumn: z.ZodOptional<z.ZodNumber>;
+        endColumn: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    field: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    claimId: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    declaredAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+    onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>>;
+    capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fenceToken: z.ZodOptional<z.ZodNumber>;
+    acquiredAt: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        committed: "committed";
+        expired: "expired";
+        canceled: "canceled";
+    }>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        heldBy: z.ZodOptional<z.ZodString>;
+        heldByClaimId: z.ZodOptional<z.ZodString>;
+        heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
+        heldByClaim: z.ZodOptional<z.ZodObject<{
+            entityType: z.ZodString;
+            entityId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            range: z.ZodOptional<z.ZodObject<{
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                startColumn: z.ZodOptional<z.ZodNumber>;
+                endColumn: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            field: z.ZodOptional<z.ZodString>;
+            fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            claimId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            declaredAt: z.ZodNumber;
+            expiresAt: z.ZodNumber;
+            onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+            }>>>>;
+            capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        policyReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WireClaim = z.infer<typeof wireClaimSchema>;
+export declare const claimRejectionSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    reason: z.ZodString;
+    target: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    heldBy: z.ZodOptional<z.ZodString>;
+    heldByKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>;
+    heldByClaimId: z.ZodOptional<z.ZodString>;
+    heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
+    heldByClaim: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        claimId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        declaredAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>>>>;
+        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    policyReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClaimRejection = z.infer<typeof claimRejectionSchema>;
+/**
+ * The point-to-point notification sent to a holder whose lease ended without
+ * a successful commit. This remains a wire-shaped target because it arrives
+ * directly from the WebSocket; the schema is the single validation boundary
+ * before the event reaches public `claims.onLost` listeners.
+ */
+export declare const claimLostSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    reason: z.ZodEnum<{
+        expired: "expired";
+        preempted: "preempted";
+    }>;
+    target: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ClaimLost = z.infer<typeof claimLostSchema>;
+/**
+ * The lease is ours without waiting — the target was free when the claim
+ * arrived. `fenceToken` is present whenever the coordinator minted one, and a
+ * write carries it back so a lapsed lease cannot apply late.
+ */
+export declare const claimAcquiredSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    fenceToken: z.ZodOptional<z.ZodNumber>;
+    target: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ClaimAcquired = z.infer<typeof claimAcquiredSchema>;
+/**
+ * A queued claim reached the head of the line and the lease is now ours. The
+ * shape matches {@link claimAcquiredSchema} exactly — the two frames differ
+ * only in whether the caller waited — but they stay separate declarations
+ * because they are separate wire contracts, and collapsing them would let a
+ * change to one silently redefine the other.
+ */
+export declare const claimGrantedSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    fenceToken: z.ZodOptional<z.ZodNumber>;
+    target: z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ClaimGranted = z.infer<typeof claimGrantedSchema>;
+/**
+ * Our claim is waiting in line behind a live holder — the same conflict
+ * {@link claimRejectionSchema} reports, delivered as a wait rather than a
+ * refusal, plus the caller's `position`.
+ *
+ * `reason` is the one member that does not carry over as required. A refusal
+ * states why it refused; a wait has only ever named the conflict through
+ * `heldBy`/`heldByClaim`, and no server has ever stamped `reason` on this
+ * frame. Requiring it here — inherited silently by extending the rejection
+ * schema — made the parse boundary reject every genuine `claim_queued` as
+ * malformed the moment frame validation went in. Optional is what the wire
+ * actually is, and it stays derived from the rejection field so the two cannot
+ * describe the value differently.
+ *
+ * `position` is advisory: a privileged reorder can move it up, so a caller
+ * that asserts monotonic position will fail in production. Only the arrival of
+ * a grant is authoritative.
+ */
+export declare const claimQueuedSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    target: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    heldBy: z.ZodOptional<z.ZodString>;
+    heldByKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>;
+    heldByClaimId: z.ZodOptional<z.ZodString>;
+    heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
+    heldByClaim: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        claimId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        declaredAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>>>>;
+        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    policyReason: z.ZodOptional<z.ZodString>;
+    position: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClaimQueued = z.infer<typeof claimQueuedSchema>;
+/**
+ * One entry in a wait-line snapshot.
+ *
+ * NOTE — this is the third spelling of a target locator on the wire: here it is
+ * `{ type, id }`, the HTTP claim DTO uses `{ model, id }`
+ * ({@link modelTargetSchema}), and the claim frames use
+ * `{ entityType, entityId }` ({@link targetRefSchema}). The schema describes
+ * what the server sends today rather than what it should send; unifying the
+ * three is a coordinated protocol change scheduled behind the protocol version.
+ * Until it happens, the translation between the spellings lives in one place —
+ * `wireTarget`, `modelTarget` and `streamTarget` in ./locator.ts — so no hop
+ * gets to invent a fourth.
+ */
+export declare const claimQueueEntrySchema: z.ZodObject<{
+    object: z.ZodLiteral<"claim">;
+    id: z.ZodString;
+    status: z.ZodLiteral<"queued">;
+    target: z.ZodObject<{
+        field: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    description: z.ZodDefault<z.ZodString>;
+    heldBy: z.ZodOptional<z.ZodString>;
+    participantKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>;
+    position: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+export type ClaimQueueEntry = z.infer<typeof claimQueueEntrySchema>;
+/**
+ * The whole wait line for one row, rebroadcast to that row's peers on every
+ * queue mutation. This is what backs the reactive
+ * `ablo.<model>.claim.queue({ id })` read, which is why it carries the full
+ * line rather than a delta against it.
+ */
+export declare const claimQueueSchema: z.ZodObject<{
+    target: z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    queue: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"claim">;
+        id: z.ZodString;
+        status: z.ZodLiteral<"queued">;
+        target: z.ZodObject<{
+            field: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            range: z.ZodOptional<z.ZodObject<{
+                startLine: z.ZodNumber;
+                endLine: z.ZodNumber;
+                startColumn: z.ZodOptional<z.ZodNumber>;
+                endColumn: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        description: z.ZodDefault<z.ZodString>;
+        heldBy: z.ZodOptional<z.ZodString>;
+        participantKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>>>;
+        position: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ClaimQueue = z.infer<typeof claimQueueSchema>;
+/**
+ * A held claim's TTL lapsed server-side. The claim is already inactive by the
+ * time this arrives, so a consumer either re-claims with a fresh credential or
+ * accepts the drop; there is nothing to release.
+ */
+export declare const claimExpiredSchema: z.ZodObject<{
+    claimId: z.ZodString;
+}, z.core.$strip>;
+export type ClaimExpired = z.infer<typeof claimExpiredSchema>;
+/**
+ * Why a claim ended without its holder releasing it, or was refused.
+ *
+ * A closed set, because the two refusals are different guarantees and a reader
+ * has to be able to tell them apart: `conflict` means someone holds the row
+ * right now and you may queue behind them, while `coordination_unavailable`
+ * means the coordinator could not answer, so nothing is known about the row.
+ * `expired` and `preempted` are the two ways a lease you held ends.
+ *
+ * The rejection frame's `reason` stays a plain string on the wire — it is
+ * frozen, and an older server may send a word not listed here. This is the
+ * reader's side of it: a value that parses becomes the typed reason, and one
+ * that does not is simply absent rather than smuggled through as prose.
+ * {@link claimExpiredSchema} and {@link claimLostSchema} already spelled their
+ * reasons as enums; this brings the refusals into line.
+ */
+export declare const claimEventReasonSchema: z.ZodEnum<{
+    conflict: "conflict";
+    expired: "expired";
+    preempted: "preempted";
+    coordination_unavailable: "coordination_unavailable";
+}>;
+export type ClaimEventReason = z.infer<typeof claimEventReasonSchema>;
+/**
+ * What a {@link ModelClaim} points at — the target locator as SDK callers see
+ * it, keyed by `model` and `id` rather than the wire schema's `entityType` and
+ * `entityId`. This is the public `ModelTarget` shape.
+ */
+export declare const modelTargetSchema: z.ZodReadonly<z.ZodObject<{
+    model: z.ZodString;
+    id: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        startColumn: z.ZodOptional<z.ZodNumber>;
+        endColumn: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    field: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>>;
+export type ModelTarget = z.infer<typeof modelTargetSchema>;
+/**
+ * The two states a claim can be observed in while it still exists.
+ *
+ * Derived from {@link publicClaimStatusSchema} rather than spelled again: the
+ * other three are terminal and drop the claim from the observable set, so a
+ * listing or a peer's view can only ever see these. Extracting them by name
+ * means a state added to the public vocabulary is a deliberate decision about
+ * whether it is observable, not a silent omission.
+ */
+export declare const heldClaimStatusSchema: z.ZodEnum<{
+    active: "active";
+    queued: "queued";
+}>;
+export type HeldClaimStatus = z.infer<typeof heldClaimStatusSchema>;
+/**
+ * ONE CLAIM — everything true about a lease at a moment: what it points at, who
+ * holds it, what they said they are doing, where it stands, and until when.
+ *
+ * Every caller-facing surface that answers a question about a claim is a
+ * PROJECTION of this record, never a second object: {@link modelClaimSchema} is
+ * what a peer may see, and `claimStateSchema` (`wire/claims.ts`) is what a
+ * caller polls about a claim of its own. Each is pinned to this record, so a
+ * field added here either reaches the people it was declared for or fails to
+ * compile.
+ *
+ * Before this, the peer-visible shape was a standalone `z.object` deriving from
+ * nothing, and the polling shape was a third. That is why it took reading four
+ * files to answer whether a heartbeat's progress reaches an asker — the
+ * declaring surface and the observing surface were kept in step by hand, and
+ * three of their shared fields had already drifted on how strictly they parse.
+ *
+ * What this record deliberately does NOT unify is the socket family
+ * ({@link wireClaimSchema} and its base). Those carry the same claim under the
+ * `entityType`/`entityId` locator rather than `model`/`id`, and they already
+ * derive from one another; collapsing the two locator spellings is a wire
+ * rename, not a projection.
+ */
+export declare const claimRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    actor: z.ZodString;
+    participantKind: z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>;
+    onBehalfOfId: z.ZodNullable<z.ZodString>;
+    onBehalfOfKind: z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>;
+    capabilityId: z.ZodNullable<z.ZodString>;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        queued: "queued";
+    }>;
+    position: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+    fenceToken: z.ZodNumber;
+    target: z.ZodReadonly<z.ZodObject<{
+        model: z.ZodString;
+        id: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ClaimRecord = z.infer<typeof claimRecordSchema>;
+/**
+ * A claim as SDK callers and the HTTP claim routes see it
+ * (`ablo.<model>.claim.state`, `GET /v1/claims`) — the resolved, peer-readable
+ * view of one active or queued claim. The client's `ModelClaim` type derives
+ * from this shape.
+ *
+ * Everything but the deprecated `field` is projected from
+ * {@link claimRecordSchema}. Four members are optional here and required on the
+ * record, and the split is the same in each case: the record says what a claim
+ * IS, while a peer's view of one may legitimately have been built without them
+ * — a queued claim has no `fenceToken`, a held one has no `position`, an older
+ * producer sends no `status`, and a claim may be declared with no description.
+ */
+export declare const modelClaimSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    actor: z.ZodString;
+    participantKind: z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>;
+    onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>>;
+    capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        queued: "queued";
+    }>>;
+    position: z.ZodOptional<z.ZodNumber>;
+    expiresAt: z.ZodNumber;
+    fenceToken: z.ZodOptional<z.ZodNumber>;
+    target: z.ZodReadonly<z.ZodObject<{
+        model: z.ZodString;
+        id: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    field: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type ModelClaim = z.infer<typeof modelClaimSchema>;
+/**
+ * The `claim_begin` payload a client sends. It carries the descriptive target
+ * and a `description` of the work, an optional duration hint, and the opt-in
+ * fair-queue flag. The server stamps the lifecycle and timestamp fields, so they
+ * are not part of this inbound shape — this is exactly what the server validates
+ * on ingest.
+ */
+export declare const claimBeginPayloadSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        startColumn: z.ZodOptional<z.ZodNumber>;
+        endColumn: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    field: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    claimId: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    estimatedMs: z.ZodOptional<z.ZodNumber>;
+    queue: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ClaimBeginPayload = z.infer<typeof claimBeginPayloadSchema>;
+/**
+ * The `claim_abandon` payload a client sends. `entityType` and `entityId` let
+ * the server dequeue a claim that is still waiting (not yet held) from the FIFO
+ * line; abandoning a claim that is already held needs only `claimId`.
+ */
+export declare const claimAbandonPayloadSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClaimAbandonPayload = z.infer<typeof claimAbandonPayloadSchema>;
+/**
+ * The `claim_reorder` payload a client sends. A privileged participant, such as
+ * a supervisor over its sub-agents, re-ranks the FIFO wait queue for an entity:
+ * `order` lists waiters by `heldBy` and `claimId` in the desired priority, and
+ * any waiter not listed keeps its relative order behind those that are. The
+ * server gates who may call this and drops an unauthorized sender. Where
+ * `claim_abandon` acts on the caller's own entry, a reorder acts on other
+ * participants' queue positions — which is why it is gated.
+ */
+export declare const claimReorderPayloadSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    order: z.ZodArray<z.ZodObject<{
+        heldBy: z.ZodString;
+        claimId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ClaimReorderPayload = z.infer<typeof claimReorderPayloadSchema>;
+/**
+ * The `claim_heartbeat` payload a client sends to extend a lease it holds (or
+ * refresh its slot in the wait queue) past the liveness window — the
+ * work-duration signal for long-running holders, distinct from the connection
+ * keepalive.
+ *
+ * The claim is identified either way: by `claimId`, or — since a claim is
+ * singular per (actor, entity) — by the full `entityType`/`entityId` target
+ * ("my claim on this row"). At least one of the two must be present. The
+ * target also lets the server resolve without a scan and is required to
+ * refresh a *queued* claim (a waiter is not in the holder set the server
+ * would otherwise search).
+ */
+export declare const claimHeartbeatPayloadSchema: z.ZodObject<{
+    claimId: z.ZodOptional<z.ZodString>;
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    ttlMs: z.ZodOptional<z.ZodNumber>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ClaimHeartbeatPayload = z.infer<typeof claimHeartbeatPayloadSchema>;
+/**
+ * The server's reply to a `claim_heartbeat`. For a socketless worker the
+ * heartbeat reply is the only inbound signal path, so it carries the lease's
+ * fate rather than a bare ok: `held` (extended to `expiresAt`), `queued`
+ * (slot refreshed; `position` is the current place in line), or `lost` (the
+ * lease expired and the queue moved on — the worker should abandon or
+ * re-queue, and any write it still attempts is caught by its `readAt` guard).
+ */
+export declare const claimHeartbeatAckPayloadSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        held: "held";
+        lost: "lost";
+    }>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodNumber>;
+    queueDepth: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ClaimHeartbeatAckPayload = z.infer<typeof claimHeartbeatAckPayloadSchema>;
+/**
+ * The batched heartbeat — one request extends every lease the caller holds
+ * on its plane (the socketless twin of the WebSocket keepalive, which renews
+ * all held leases on every ping). For a worker holding many rows this is one
+ * round trip per cadence instead of one per claim. Queued slots are not
+ * batch-refreshed: a waiter knows its target and beats it directly.
+ */
+export declare const claimHeartbeatBatchPayloadSchema: z.ZodObject<{
+    ttlMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ClaimHeartbeatBatchPayload = z.infer<typeof claimHeartbeatBatchPayloadSchema>;
+/** Reply to a batched heartbeat: one ack entry per lease that was extended. */
+export declare const claimHeartbeatBatchAckPayloadSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        claimId: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            held: "held";
+            lost: "lost";
+        }>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodNumber>;
+        queueDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ClaimHeartbeatBatchAckPayload = z.infer<typeof claimHeartbeatBatchAckPayloadSchema>;
+/**
+ * The `update_subscription` payload a client sends. It replaces the
+ * connection's read interest with the complete set of sync groups — the read
+ * counterpart to a claim, with no write lock and no TTL. Each entry is a
+ * {@link syncGroupInputSchema} (`'default'` or a branded `kind:id`), so a
+ * malformed group is rejected on ingest rather than silently indexed. The
+ * element type is strict because this is untrusted client input.
+ */
+export declare const updateSubscriptionPayloadSchema: z.ZodObject<{
+    syncGroups: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"default">, z.core.$ZodBranded<z.ZodTemplateLiteral<`${string}:${string}`>, "SyncGroup", "out">]>>;
+}, z.core.$strip>;
+export type UpdateSubscriptionPayload = z.infer<typeof updateSubscriptionPayloadSchema>;
+/**
+ * `subscription_ack` payload (server → client). Echoes the connection's
+ * effective read set after the update (unchanged on rejection — the update is
+ * atomic). `error` is present iff `success` is false (e.g. a scoped key
+ * requesting a group outside its grant). `syncGroups` is lenient
+ * (`z.string()`) here, not branded: it is the server's own echo for display,
+ * not untrusted input, and includes base anchors like `org:<id>`.
+ */
+export declare const subscriptionAckPayloadSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    syncGroups: z.ZodArray<z.ZodString>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SubscriptionAckPayload = z.infer<typeof subscriptionAckPayloadSchema>;
+export declare const commitOperationTypeSchema: z.ZodEnum<{
+    CREATE: "CREATE";
+    UPDATE: "UPDATE";
+    DELETE: "DELETE";
+    ARCHIVE: "ARCHIVE";
+    UNARCHIVE: "UNARCHIVE";
+}>;
+export type CommitOperationType = z.infer<typeof commitOperationTypeSchema>;
+/**
+ * A single mutation in a commit batch, as it arrives on the wire. Extends the
+ * optimistic `writeGuard` (`readAt`/`onStale`/`bypass`) — the structural link
+ * that makes "every write is stale-guarded" legible in the type, not just in
+ * prose.
+ */
+export declare const commitOperationSchema: z.ZodObject<{
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    bypass: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodEnum<{
+        CREATE: "CREATE";
+        UPDATE: "UPDATE";
+        DELETE: "DELETE";
+        ARCHIVE: "ARCHIVE";
+        UNARCHIVE: "UNARCHIVE";
+    }>;
+    model: z.ZodString;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    input: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type CommitOperation = z.infer<typeof commitOperationSchema>;
+/**
+ * Any commit operation on the wire — the runtime-validated ingest contract.
+ * Commit operations carry replace (last-write-wins) semantics, guarded by the
+ * optimistic write guard. It is a distinct alias from {@link CommitOperation}
+ * so the server's ingest boundary reads as "any op on the wire", even though
+ * the two shapes are identical.
+ */
+export type AnyCommitOperation = CommitOperation;
+export declare const presenceKindSchema: z.ZodEnum<{
+    enter: "enter";
+    update: "update";
+    leave: "leave";
+}>;
+export type PresenceKind = z.infer<typeof presenceKindSchema>;
+/**
+ * What a participant is actively working on (agents fill this in).
+ *
+ * The two backpressure fields are part of the frame, not an extension of it:
+ * an agent worker announces them on every step, and an orchestrator reading
+ * peer activity routes work by them. They are declared here because a reader
+ * that validates this frame would otherwise drop them on the floor — the
+ * server passes both through without interpreting either.
+ */
+export declare const presenceActivitySchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    range: z.ZodOptional<z.ZodObject<{
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+        startColumn: z.ZodOptional<z.ZodNumber>;
+        endColumn: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    field: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    action: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+    loadFactor: z.ZodOptional<z.ZodNumber>;
+    acceptingNewWork: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PresenceActivity = z.infer<typeof presenceActivitySchema>;
+/**
+ * Full `presence_update` frame as the server broadcasts it. The activity +
+ * `activeClaims` are the observation surface for the other two layers —
+ * rendered, never acted on as enforcement.
+ *
+ * Open for the same reason {@link presenceUpdatePayloadSchema} is, and it has to
+ * be the same in both directions: whatever vocabulary an application announces
+ * through presence, it reads back off its peers' frames. A reader that parsed
+ * this strictly would validate the frame and quietly discard the part the
+ * application actually came for.
+ */
+export declare const presenceUpdateSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        enter: "enter";
+        update: "update";
+        leave: "leave";
+    }>;
+    userId: z.ZodString;
+    syncGroups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodString;
+    timezone: z.ZodOptional<z.ZodString>;
+    customStatus: z.ZodOptional<z.ZodString>;
+    activity: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        action: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        loadFactor: z.ZodOptional<z.ZodNumber>;
+        acceptingNewWork: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    participantKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>;
+    activeClaims: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        claimId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        declaredAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>>>>;
+        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fenceToken: z.ZodOptional<z.ZodNumber>;
+        acquiredAt: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            committed: "committed";
+            expired: "expired";
+            canceled: "canceled";
+        }>>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodOptional<z.ZodString>;
+            heldBy: z.ZodOptional<z.ZodString>;
+            heldByClaimId: z.ZodOptional<z.ZodString>;
+            heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
+            heldByClaim: z.ZodOptional<z.ZodObject<{
+                entityType: z.ZodString;
+                entityId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                range: z.ZodOptional<z.ZodObject<{
+                    startLine: z.ZodNumber;
+                    endLine: z.ZodNumber;
+                    startColumn: z.ZodOptional<z.ZodNumber>;
+                    endColumn: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                field: z.ZodOptional<z.ZodString>;
+                fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                claimId: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                declaredAt: z.ZodNumber;
+                expiresAt: z.ZodNumber;
+                onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+                    user: "user";
+                    agent: "agent";
+                    system: "system";
+                }>>>>;
+                capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            policyReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    delegatedFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type PresenceUpdate = z.infer<typeof presenceUpdateSchema>;
+/**
+ * @deprecated Renamed to {@link presenceUpdateSchema}. Removed in 0.36.0.
+ *
+ * `Frame` was the only such suffix in this vocabulary: every other frame the
+ * server sends is named plainly — {@link claimLostSchema},
+ * {@link claimAcquiredSchema}, {@link claimRejectionSchema} — and the client's
+ * half carries `Payload`. One name did not follow the rule the other fifteen do.
+ */
+export declare const presenceUpdateFrameSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        enter: "enter";
+        update: "update";
+        leave: "leave";
+    }>;
+    userId: z.ZodString;
+    syncGroups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodString;
+    timezone: z.ZodOptional<z.ZodString>;
+    customStatus: z.ZodOptional<z.ZodString>;
+    activity: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        action: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        loadFactor: z.ZodOptional<z.ZodNumber>;
+        acceptingNewWork: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    participantKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        system: "system";
+    }>>>;
+    activeClaims: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        claimId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        declaredAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>>>>;
+        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fenceToken: z.ZodOptional<z.ZodNumber>;
+        acquiredAt: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            committed: "committed";
+            expired: "expired";
+            canceled: "canceled";
+        }>>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodOptional<z.ZodString>;
+            heldBy: z.ZodOptional<z.ZodString>;
+            heldByClaimId: z.ZodOptional<z.ZodString>;
+            heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
+            heldByClaim: z.ZodOptional<z.ZodObject<{
+                entityType: z.ZodString;
+                entityId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                range: z.ZodOptional<z.ZodObject<{
+                    startLine: z.ZodNumber;
+                    endLine: z.ZodNumber;
+                    startColumn: z.ZodOptional<z.ZodNumber>;
+                    endColumn: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                field: z.ZodOptional<z.ZodString>;
+                fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                claimId: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                declaredAt: z.ZodNumber;
+                expiresAt: z.ZodNumber;
+                onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+                    user: "user";
+                    agent: "agent";
+                    system: "system";
+                }>>>>;
+                capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            policyReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    delegatedFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+/** @deprecated Renamed to {@link PresenceUpdate}. Removed in 0.36.0. */
+export type PresenceUpdateFrame = PresenceUpdate;
+/**
+ * The `presence_update` payload a client SENDS — deliberately much smaller
+ * than the frame the server broadcasts back.
+ *
+ * Everything that identifies or situates the participant is stamped by the
+ * server and cannot be declared here: `userId`, `participantKind`, `isAgent`,
+ * `syncGroups`, `timestamp`, `kind`, and `delegatedFrom` all come from the
+ * connection's own identity. A client that sends them is not believed — an
+ * older SDK once hardcoded `isAgent: true` on every announce, and because the
+ * payload was spread into the broadcast unfiltered, every human session
+ * rendered to its peers as an agent. Parsing an inbound payload through this
+ * schema and broadcasting the *result* is what makes that structurally
+ * impossible rather than a rule the broadcast has to remember.
+ *
+ * `status` is a plain string, matching the outbound frame: the three canonical
+ * values are conventions the presence UI understands, not a closed set the
+ * protocol enforces.
+ *
+ * The payload is deliberately OPEN — `catchall` keeps keys this schema does not
+ * name. Presence is the one frame an application extends: an agent mesh
+ * announces its own coordination vocabulary through it and reads it back off
+ * peer frames, without the protocol having to learn each app's words. So the
+ * fields named here are validated and typed, and anything else rides along
+ * untouched. Openness is not the same as trust: the server-stamped identity
+ * fields are applied AFTER this payload is spread into the broadcast, so a
+ * client that sends its own `userId` or `isAgent` is overwritten either way.
+ */
+export declare const presenceUpdatePayloadSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    activity: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        action: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        loadFactor: z.ZodOptional<z.ZodNumber>;
+        acceptingNewWork: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    activeClaims: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        range: z.ZodOptional<z.ZodObject<{
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+            startColumn: z.ZodOptional<z.ZodNumber>;
+            endColumn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        field: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        claimId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        declaredAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            system: "system";
+        }>>>>;
+        capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fenceToken: z.ZodOptional<z.ZodNumber>;
+        acquiredAt: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            committed: "committed";
+            expired: "expired";
+            canceled: "canceled";
+        }>>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodOptional<z.ZodString>;
+            heldBy: z.ZodOptional<z.ZodString>;
+            heldByClaimId: z.ZodOptional<z.ZodString>;
+            heldByExpiresAt: z.ZodOptional<z.ZodNumber>;
+            heldByClaim: z.ZodOptional<z.ZodObject<{
+                entityType: z.ZodString;
+                entityId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                range: z.ZodOptional<z.ZodObject<{
+                    startLine: z.ZodNumber;
+                    endLine: z.ZodNumber;
+                    startColumn: z.ZodOptional<z.ZodNumber>;
+                    endColumn: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                field: z.ZodOptional<z.ZodString>;
+                fields: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                claimId: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                declaredAt: z.ZodNumber;
+                expiresAt: z.ZodNumber;
+                onBehalfOfId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                onBehalfOfKind: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodEnum<{
+                    user: "user";
+                    agent: "agent";
+                    system: "system";
+                }>>>>;
+                capabilityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            policyReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    timezone: z.ZodOptional<z.ZodString>;
+    customStatus: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type PresenceUpdatePayload = z.infer<typeof presenceUpdatePayloadSchema>;