@abloatai/ablo 0.36.0 → 0.37.0

package/dist/transaction/wire/claims.d.ts

@@ -1,530 +0,0 @@
-/**
- * The request bodies for the claim routes.
- *
- * A claim is a lease over a row, so these cross the same boundary the commit
- * body does and belong here for the same reason: one definition site, which the
- * server validates against and the published OpenAPI reference derives from.
- *
- * Before this existed both claim routes cast `JSON.parse` output to a
- * hand-written interface, so an untrusted body reached the coordinator
- * unvalidated and the reference described the shape from memory.
- */
-import { z } from 'zod';
-/**
- * How long a lease runs when the caller does not ask for a length.
- *
- * One definition for both ends: the server stamps `expiresAt` with it, and the
- * client's auto-heartbeat derives its cadence from it, so a claim that names no
- * TTL beats comfortably inside the window the server actually granted.
- */
-export declare const DEFAULT_CLAIM_TTL_MS = 60000;
-/**
- * A lease length on the wire, in the SDK's one duration grammar: a
- * unit-suffixed string (`'500ms'`, `'30s'`, `'5m'`, `'24h'`) or a bare number of
- * **seconds** — the same reading `ttlSeconds` has everywhere else in the API.
- *
- * It used to be `z.union([z.string(), z.number()])`, and the units lived only in
- * the route's private parser, which read a bare number as MILLISECONDS. So the
- * SDK computed its heartbeat cadence from one grammar while the server granted a
- * lease under another, and `ttl: 300` meant five minutes to the client and three
- * hundred milliseconds to the server. Publishing the grammar is what makes that
- * class of disagreement impossible: there is now one pattern, emitted into the
- * contract, and one parser behind it.
- */
-export declare const claimTtlSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
-/**
- * A wire TTL as milliseconds — the single reading of the grammar above.
- *
- * The server calls this rather than carrying its own parser. An absent TTL takes
- * {@link DEFAULT_CLAIM_TTL_MS}; anything present has already been validated by
- * {@link claimTtlSchema} at the boundary, so a malformed duration is a 400 at the
- * door rather than a silent one-minute lease that lapses mid-work.
- */
-export declare function claimTtlMs(ttl: z.infer<typeof claimTtlSchema> | null | undefined): number;
-/** The row a claim points at, when it is not already given by the URL. */
-export declare const claimTargetSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
-    id: z.ZodOptional<z.ZodNullable<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 ClaimTargetBody = z.infer<typeof claimTargetSchema>;
-/**
- * `POST /v1/claims` and `POST /v1/models/{model}/{id}/claim`.
- *
- * Every field is optional: on the model-scoped route the target comes from the
- * URL, and a bare claim means "I'm editing this row".
- */
-export declare const claimRequestSchema: z.ZodObject<{
-    claimId: z.ZodOptional<z.ZodString>;
-    target: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        model: z.ZodOptional<z.ZodString>;
-        id: z.ZodOptional<z.ZodNullable<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>>>;
-    reason: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    ttl: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
-    queue: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type ClaimRequest = z.infer<typeof claimRequestSchema>;
-/**
- * `POST /v1/models/{model}/{id}/claim/heartbeat`.
- *
- * An empty body is a plain "still working" beat. `ttl` extends the lease;
- * `claimId` names the exact lease instead of "my claim on this row".
- */
-export declare const claimHeartbeatRequestSchema: z.ZodObject<{
-    claimId: z.ZodOptional<z.ZodString>;
-    ttl: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
-    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-export type ClaimHeartbeatRequest = z.infer<typeof claimHeartbeatRequestSchema>;
-/**
- * The query string on `GET /v1/models/{model}`.
- *
- * Values arrive as strings, so this describes the wire spelling rather than the
- * parsed result — which is what a caller and the reference both need.
- */
-export declare const listQuerySchema: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodString>;
-    order_by: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodEnum<{
-        asc: "asc";
-        desc: "desc";
-    }>>;
-    starting_after: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ListQuery = z.infer<typeof listQuerySchema>;
-/**
- * A claim's current state, as returned by `GET /v1/claims/{claimId}`.
- *
- * This is the polling shape, and only the polling shape. Acquiring a claim
- * answers with {@link claimAcquireResponseSchema}, whose two arms are spelled
- * differently — that route was documented against this schema for a while, and
- * the reference described a response the server has never sent.
- *
- * This is the shape that makes queued grants reachable without a socket: the
- * caller enqueues, receives `queued`, heartbeats to stay in line, and polls
- * until `status` becomes `active`, at which point `fenceToken` is present and
- * the work can begin.
- *
- * Two properties are load-bearing and easy to get wrong from the outside:
- *
- * **`position` is advisory.** A privileged caller can reorder the wait line, so
- * a position can go UP between polls. Only `status` is authoritative — a client
- * that asserts monotonic position will fail in production, not in review.
- *
- * **`fenceToken` appears at grant, never at enqueue.** It orders by acquisition
- * rather than by arrival, which is what the fence watermark depends on; a token
- * handed out while queued would break that ordering.
- *
- * There is deliberately no `readAt` here. A watermark records the state a
- * writer reasoned against, and a caller that has just been granted a claim has
- * not read anything yet — it reads next. Stamping one at grant would assert a
- * premise the caller never established, so the holder gets its watermark from
- * its own read, the same way the socket path takes it from a local snapshot.
- */
-export declare const claimStateSchema: z.ZodObject<{
-    id: z.ZodString;
-    expiresAt: z.ZodOptional<z.ZodNumber>;
-    fenceToken: z.ZodOptional<z.ZodNumber>;
-    position: z.ZodOptional<z.ZodNumber>;
-    object: z.ZodLiteral<"claim">;
-    status: z.ZodEnum<{
-        active: "active";
-        committed: "committed";
-        expired: "expired";
-        canceled: "canceled";
-        queued: "queued";
-    }>;
-}, z.core.$strip>;
-export type ClaimState = z.infer<typeof claimStateSchema>;
-/**
- * `POST /v1/claims` and `POST /v1/models/{model}/{id}/claim`, **201** — the
- * target was free and the lease is yours. The claim is nested rather than
- * flattened because the outer object is the created resource's envelope, and
- * `id` is its identity.
- */
-export declare const claimAcquiredResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    object: z.ZodLiteral<"claim">;
-    status: z.ZodLiteral<"active">;
-    fenceToken: z.ZodOptional<z.ZodNumber>;
-    expiresAt: z.ZodOptional<z.ZodNumber>;
-    claim: 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>>;
-}, z.core.$strip>;
-export type ClaimAcquiredResponse = z.infer<typeof claimAcquiredResponseSchema>;
-/**
- * The same two routes, **202** — the row was already held and `queue: true`
- * put you in line. The grant arrives later on the caller's stream, or through
- * `GET /v1/claims/{claimId}`.
- *
- * Shaped as a claim resource, exactly like the 201, because that is what it is:
- * a queue entry is a lease in a different state — the reason one `DELETE`
- * serves both, and the reason the poll can move one to the other. It once
- * withheld `object` and `id` on the argument that a queued claim is not yet a
- * created resource, which read as principled and cost a caller the ability to
- * treat the two answers as one type.
- */
-export declare const claimQueuedResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    object: z.ZodLiteral<"claim">;
-    status: z.ZodLiteral<"queued">;
-    position: z.ZodNumber;
-    heldBy: z.ZodOptional<z.ZodString>;
-    expiresAt: 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>>;
-}, z.core.$strip>;
-export type ClaimQueuedResponse = z.infer<typeof claimQueuedResponseSchema>;
-/**
- * Either answer to a claim acquire — one resource, two states, told apart by
- * `status`.
- *
- * A real discriminated union, which it could not be while the arms disagreed
- * about what the handle was called (`id` on the 201, `claimId` on the 202) and
- * only one of them said `object`. `claimRecordSchema.id` states the rule both
- * now follow: `id` where the claim IS the resource, `claimId` where some other
- * object names one.
- */
-export declare const claimAcquireResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    id: z.ZodString;
-    object: z.ZodLiteral<"claim">;
-    status: z.ZodLiteral<"active">;
-    fenceToken: z.ZodOptional<z.ZodNumber>;
-    expiresAt: z.ZodOptional<z.ZodNumber>;
-    claim: 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>>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    object: z.ZodLiteral<"claim">;
-    status: z.ZodLiteral<"queued">;
-    position: z.ZodNumber;
-    heldBy: z.ZodOptional<z.ZodString>;
-    expiresAt: 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>>;
-}, z.core.$strip>], "status">;
-export type ClaimAcquireResponse = z.infer<typeof claimAcquireResponseSchema>;
-/**
- * `POST /v1/models/{model}/{id}/claim/heartbeat`.
- *
- * `status` never carries `'lost'` in a body: a lease that ended answers with a
- * 409 `claim_lost` instead, which the error mapping raises as
- * `AbloClaimedError` before any of this is read. That is the one way this
- * differs from the WebSocket {@link claimHeartbeatAckPayloadSchema}, whose
- * three-state status includes the loss.
- */
-export declare const claimHeartbeatReplySchema: z.ZodObject<{
-    object: z.ZodLiteral<"claim_heartbeat">;
-    claimId: z.ZodString;
-    status: z.ZodEnum<{
-        queued: "queued";
-        held: "held";
-    }>;
-    expiresAt: z.ZodOptional<z.ZodNumber>;
-    queueDepth: z.ZodOptional<z.ZodNumber>;
-    position: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type ClaimHeartbeatReply = z.infer<typeof claimHeartbeatReplySchema>;
-/** `POST /v1/claims/heartbeat` — one ack per lease the batch extended. */
-export declare const claimHeartbeatBatchReplySchema: z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    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 ClaimHeartbeatBatchReply = z.infer<typeof claimHeartbeatBatchReplySchema>;
-/**
- * The query string on `GET /v1/claims` — the four questions you may ask about
- * live work, which are the same four the audit log already answers about
- * finished work.
- *
- * The names are audit's names on purpose (`routes/dashboard/audit.ts` filters on
- * `actorId`, `actorKind`, `onBehalfOfId`, `capabilityId`). Asking "everything
- * agent A is doing" and "everything agent A did" should not require learning two
- * vocabularies for one idea; the tense is the only thing that differs.
- *
- * `model` and `id` scope to a row and are the original axis. The other three
- * scope to a participant, and a request may combine them — "what is this agent
- * doing to this invoice" is both.
- *
- * Every value is optional, and an omitted filter is not a filter: a bare request
- * lists everything the caller's organization holds.
- */
-export declare const claimListQuerySchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
-    id: z.ZodOptional<z.ZodString>;
-    field: z.ZodOptional<z.ZodString>;
-    actorId: z.ZodOptional<z.ZodString>;
-    actorKind: z.ZodOptional<z.ZodPreprocess<z.ZodEnum<{
-        user: "user";
-        agent: "agent";
-        system: "system";
-    }>>>;
-    onBehalfOfId: z.ZodOptional<z.ZodString>;
-    capabilityId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ClaimListQuery = z.infer<typeof claimListQuerySchema>;
-/**
- * `GET /v1/claims` — who holds what, and who waits.
- *
- * One list in the shape every other list has, because holders and waiters are
- * the same resource in two states: each entry carries `status`, and a `queued`
- * one carries its `position`. Holders come first, then the wait line in order.
- *
- * It used to answer `{ claims[], queue[] }` — a bespoke envelope on the endpoint
- * a coordination client touches most, which cost a generated client a
- * special-cased model to read the one call it makes constantly.
- *
- * Waiters appear only when the request names both a `model` and an `id`: a wait
- * line belongs to one row, so an unscoped listing has none to report.
- */
-export declare const claimListResponseSchema: z.ZodObject<{
-    object: z.ZodLiteral<"list">;
-    data: z.ZodReadonly<z.ZodArray<z.ZodType<Readonly<{
-        id: string;
-        actor: string;
-        participantKind: "user" | "agent" | "system";
-        expiresAt: number;
-        target: Readonly<{
-            model: string;
-            id: string;
-            path?: string | undefined;
-            range?: {
-                startLine: number;
-                endLine: number;
-                startColumn?: number | undefined;
-                endColumn?: number | undefined;
-            } | undefined;
-            field?: string | undefined;
-            fields?: readonly string[] | undefined;
-            meta?: Record<string, unknown> | undefined;
-        }>;
-        onBehalfOfId?: string | null | undefined;
-        onBehalfOfKind?: "user" | "agent" | "system" | null | undefined;
-        capabilityId?: string | null | undefined;
-        description?: string | undefined;
-        status?: "active" | "queued" | undefined;
-        position?: number | undefined;
-        fenceToken?: number | undefined;
-        meta?: Record<string, unknown> | undefined;
-        field?: string | undefined;
-    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-        id: string;
-        actor: string;
-        participantKind: "user" | "agent" | "system";
-        expiresAt: number;
-        target: Readonly<{
-            model: string;
-            id: string;
-            path?: string | undefined;
-            range?: {
-                startLine: number;
-                endLine: number;
-                startColumn?: number | undefined;
-                endColumn?: number | undefined;
-            } | undefined;
-            field?: string | undefined;
-            fields?: readonly string[] | undefined;
-            meta?: Record<string, unknown> | undefined;
-        }>;
-        onBehalfOfId?: string | null | undefined;
-        onBehalfOfKind?: "user" | "agent" | "system" | null | undefined;
-        capabilityId?: string | null | undefined;
-        description?: string | undefined;
-        status?: "active" | "queued" | undefined;
-        position?: number | undefined;
-        fenceToken?: number | undefined;
-        meta?: Record<string, unknown> | undefined;
-        field?: string | undefined;
-    }>, unknown>>>>;
-    has_more: z.ZodBoolean;
-    next_cursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type ClaimListResponse = z.infer<typeof claimListResponseSchema>;
-/**
- * `POST /v1/models/{model}/{id}/claim/reorder` — re-rank the wait line.
- *
- * `claimId` rather than `id` here by the rule in {@link claimRecordSchema}: an
- * entry in this list names a claim, it is not one. The server parsed this body
- * by hand — `JSON.parse(raw) as { order?: … }`, a cast onto an inline shape at a
- * wire boundary — until it had a schema to parse against.
- */
-export declare const claimReorderRequestSchema: z.ZodObject<{
-    order: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        heldBy: z.ZodString;
-        claimId: z.ZodString;
-    }, z.core.$strip>>>>;
-}, z.core.$strip>;
-export type ClaimReorderRequest = z.infer<typeof claimReorderRequestSchema>;
-/** The reorder reply. */
-export declare const claimReorderReplySchema: z.ZodObject<{
-    object: z.ZodLiteral<"claim_reorder">;
-    reordered: z.ZodBoolean;
-}, z.core.$strip>;
-export type ClaimReorderReply = z.infer<typeof claimReorderReplySchema>;
-/**
- * `DELETE /v1/claims/{claimId}` and `DELETE /v1/models/{model}/{id}/claim`.
- *
- * `released` distinguishes "your lease is gone because this call ended it" from
- * "there was nothing of yours to end" — both are success, and a caller
- * retrying a release deserves to know which happened. The two routes answered
- * `{ ok: true }` and `{ ok, released }`: two shapes, neither written down, and
- * `ok` restating the status code.
- */
-export declare const claimReleaseReplySchema: z.ZodObject<{
-    object: z.ZodLiteral<"claim_release">;
-    released: z.ZodBoolean;
-}, z.core.$strip>;
-export type ClaimReleaseReply = z.infer<typeof claimReleaseReplySchema>;