@abloatai/ablo 0.36.0 → 0.37.1

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

@@ -1,1536 +0,0 @@
-import { z } from 'zod';
-import { type FieldRef } from '../schema/fieldRef.js';
-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 span within a text-bearing part of a row (section body, doc, cell).
- *
- * Overlap is judged on the line axis alone: two ranges conflict when their
- * `[startLine, endLine]` intervals intersect, and columns ride along for
- * display. An editor that addresses by integer position rather than by line
- * maps that position axis straight onto `startLine`/`endLine` — the test is
- * plain interval intersection and never assumes the units are lines of a file.
- */
-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>;
-/**
- * An app-defined claimable part name — a cell (`'B2'`), a section id, a
- * block — made explicit with {@link part}. The schema's own field names need
- * no marker; a name that is NOT a field does, so looseness is a visible
- * decision at the call site rather than a silent absorber of typos.
- *
- * A small object rather than a branded string on purpose: a brand makes a
- * concrete schema's claim params mutually unassignable with the erased
- * `SchemaRecord` view, and the react context boundary erases and restores
- * exactly that way. The object member stays pairwise comparable, so no
- * boundary needs a cast through `unknown`.
- */
-export interface ClaimPart {
-    readonly part: string;
-}
-/**
- * Name an app-defined part of a row for a claim target: `part('B2')` for a
- * cell, `part('sec_intro')` for a section. The conflict rule compares part
- * names as opaque case-insensitive strings, so any name is legal on the
- * wire — this marker exists purely so the type surface stays definite about
- * the model's own fields.
- */
-export declare function part(name: string): ClaimPart;
-/**
- * The wire spelling of a part name, from whichever spelling the caller used.
- *
- * Three, because they are three different promises. A {@link FieldRef} —
- * `schema.fields.tasks.status` — is a field the schema declares, so a name that
- * does not exist never compiles. `part('B2')` is a name the schema does not
- * know and says so. A bare string is neither, and survives only because the
- * erased `SchemaRecord` view and untyped callers still need it.
- *
- * All three become the same string here: the wire has always carried names, and
- * what differs is how much was known before the crossing.
- */
-export declare function partName(value: string | ClaimPart | FieldRef): string;
-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>;
-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>;
-export declare const trackDependencySchema: z.ZodUnion<readonly [z.ZodObject<{
-    id: z.ZodString;
-    model: 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>;
-/**
- * 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";
-    coordination_unavailable: "coordination_unavailable";
-    preempted: "preempted";
-}>;
-export type ClaimEventReason = z.infer<typeof claimEventReasonSchema>;
-/**
- * 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.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
-        conflict: "conflict";
-        expired: "expired";
-        coordination_unavailable: "coordination_unavailable";
-        preempted: "preempted";
-    }>>>;
-    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.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
-        conflict: "conflict";
-        expired: "expired";
-        coordination_unavailable: "coordination_unavailable";
-        preempted: "preempted";
-    }>>>>;
-}, 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>;
-/**
- * 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>;
-/**
- * How many scopes one frame may name. A coarse abuse ceiling, not a business
- * limit: a connection legitimately watches a handful of entities, and a list
- * this long is an amplification attempt rather than a workload. Declared here,
- * beside the two frames it bounds, so neither can be given a different answer.
- */
-export declare const MAX_FRAME_SYNC_GROUPS = 200;
-/**
- * The `claim` payload a client sends — the frame behind `join`.
- *
- * It opens one participant claim: the connection is added to each named
- * scope's fan-out under `claimId`, announced into its presence roster, and
- * holds that interest until `release`, the TTL lapses, or the socket closes.
- * The handle is client-chosen because the client must be able to `release`
- * the exact claim it opened while others stay open.
- *
- * This shape was, for a long time, written three times — built as a literal in
- * the transport, restated as an interface on the server, and read back through
- * a cast in the frame handler — which is how the frame came to be the only
- * coordination message with no runtime check on the way in.
- */
-export declare const participantClaimPayloadSchema: z.ZodObject<{
-    claimId: z.ZodString;
-    syncGroups: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"default">, z.core.$ZodBranded<z.ZodTemplateLiteral<`${string}:${string}`>, "SyncGroup", "out">]>>;
-    capabilityToken: z.ZodOptional<z.ZodString>;
-    ttlSeconds: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type ParticipantClaimPayload = z.infer<typeof participantClaimPayloadSchema>;
-/**
- * The `release` payload — drop one participant claim by its handle.
- *
- * A projection of the claim it releases rather than a second object, so the
- * handle cannot be spelled one way when opened and another when dropped.
- * Idempotent by contract: the server accepts an unknown handle silently, so a
- * client releasing everything at shutdown never has to check what is still open.
- */
-export declare const participantReleasePayloadSchema: z.ZodObject<{
-    claimId: z.ZodString;
-}, z.core.$strip>;
-export type ParticipantReleasePayload = z.infer<typeof participantReleasePayloadSchema>;
-/**
- * The `update_subscription` payload a client sends. It replaces the
- * connection's read interest with the complete set of sync groups — the
- * unleased counterpart to {@link participantClaimPayloadSchema}, with no
- * handle, no TTL, and no roster entry.
- */
-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>;