@abloatai/transaction 0.37.0

package/dist/wire/commit.d.ts

@@ -0,0 +1,604 @@
+/**
+ * Canonical runtime contracts for commit settlement.
+ *
+ * A commit crosses several boundaries during its lifetime: the server's
+ * execution cache, the HTTP/WS receipt, and the client's acknowledgement
+ * tracker. Those boundaries intentionally have different envelopes, but they
+ * all compose the same settlement vocabulary from this module:
+ *
+ *   - `confirmed` — the authoritative change is visible at a sync watermark.
+ *   - `queued` — a connected source durably accepted the write and only its
+ *     correlated authoritative source delta (WAL for direct, endpoint event
+ *     for endpoint-only), identified by `correlationId`, may promote it.
+ *
+ * Keeping the variants discriminated here makes an impossible receipt (most
+ * importantly, `queued` without a correlation) unrepresentable at every
+ * untrusted boundary without collapsing the distinct lifecycle envelopes into
+ * one giant object.
+ */
+import { z } from 'zod';
+import type { ErrorCode } from '../errorCodes.js';
+/** Matches the permanent source/idempotency-key ceiling. */
+export declare const COMMIT_CORRELATION_ID_MAX_LENGTH = 255;
+/** Opaque server-authored identity shared by a queued receipt and its authoritative source delta. */
+export declare const correlationIdSchema: z.ZodString;
+export type CorrelationId = z.infer<typeof correlationIdSchema>;
+export declare const commitStatusSchema: z.ZodEnum<{
+    queued: "queued";
+    confirmed: "confirmed";
+}>;
+export type CommitStatus = z.infer<typeof commitStatusSchema>;
+/**
+ * The settlement states a write may block on — extracted from the reported
+ * vocabulary above, never restated beside it. `commitStatusSchema` is every
+ * state a server can report; this is the subset a caller can usefully wait for,
+ * and the two are not the same question: one describes an outcome, the other a
+ * request.
+ *
+ * `.extract` keeps the relationship mechanical in both directions. Renaming a
+ * settlement state breaks this line at build time, and adding one that nobody
+ * can block on — a commit parked for a human, say — does not become a legal
+ * `wait` merely by being added above. Both the `wait` option's runtime
+ * validator and its interface derive from here, so they cannot disagree.
+ */
+export declare const commitWaitSchema: z.ZodEnum<{
+    queued: "queued";
+    confirmed: "confirmed";
+}>;
+export type CommitWait = z.infer<typeof commitWaitSchema>;
+/** The one settlement discriminant shared by every commit boundary. */
+export declare const commitSettlementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "status">;
+export type CommitSettlement = z.infer<typeof commitSettlementSchema>;
+/**
+ * Successful HTTP/WS receipt. This schema is deliberately strict about the
+ * settlement discriminant. Zod's default object behavior strips additive
+ * fields, which is forward compatible without allowing server-internal
+ * recovery evidence to leak through a parsed wire receipt.
+ */
+export declare const commitReceiptSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>], "status">;
+export type CommitReceiptWire = z.infer<typeof commitReceiptSchema>;
+/** The failure arm is separate: queued/confirmed always imply `success:true`. */
+export declare const rejectedCommitReceiptSchema: z.ZodObject<{
+    object: z.ZodLiteral<"commit_receipt">;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<false>;
+    status: z.ZodLiteral<"rejected">;
+    lastSyncId: z.ZodOptional<z.ZodNumber>;
+    ops: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodObject<{
+        code: z.ZodCustom<ErrorCode, ErrorCode>;
+        message: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        requiredCapability: z.ZodOptional<z.ZodObject<{
+            scope: z.ZodString;
+            constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>>>;
+            issuer: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+            ttlSeconds: z.ZodPreprocess<z.ZodOptional<z.ZodNumber>>;
+            nonce: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RejectedCommitReceiptWire = z.infer<typeof rejectedCommitReceiptSchema>;
+export declare const mutationResultPayloadSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    object: z.ZodLiteral<"commit_receipt">;
+    id: z.ZodOptional<z.ZodString>;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<true>;
+    lastSyncId: z.ZodNumber;
+    ops: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>], "status">, z.ZodObject<{
+    object: z.ZodLiteral<"commit_receipt">;
+    clientTxId: z.ZodString;
+    serverTxId: z.ZodString;
+    success: z.ZodLiteral<false>;
+    status: z.ZodLiteral<"rejected">;
+    lastSyncId: z.ZodOptional<z.ZodNumber>;
+    ops: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodObject<{
+        code: z.ZodCustom<ErrorCode, ErrorCode>;
+        message: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        requiredCapability: z.ZodOptional<z.ZodObject<{
+            scope: z.ZodString;
+            constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>>>;
+            issuer: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+            ttlSeconds: z.ZodPreprocess<z.ZodOptional<z.ZodNumber>>;
+            nonce: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export type MutationResultPayload = z.infer<typeof mutationResultPayloadSchema>;
+export declare const mutationResultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"mutation_result">;
+    payload: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"queued">;
+        correlationId: z.ZodString;
+        object: z.ZodLiteral<"commit_receipt">;
+        id: z.ZodOptional<z.ZodString>;
+        clientTxId: z.ZodString;
+        serverTxId: z.ZodString;
+        success: z.ZodLiteral<true>;
+        lastSyncId: z.ZodNumber;
+        ops: z.ZodNumber;
+        notifications: z.ZodOptional<z.ZodArray<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>>>;
+        missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"confirmed">;
+        correlationId: z.ZodOptional<z.ZodString>;
+        object: z.ZodLiteral<"commit_receipt">;
+        id: z.ZodOptional<z.ZodString>;
+        clientTxId: z.ZodString;
+        serverTxId: z.ZodString;
+        success: z.ZodLiteral<true>;
+        lastSyncId: z.ZodNumber;
+        ops: z.ZodNumber;
+        notifications: z.ZodOptional<z.ZodArray<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>>>;
+        missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>], "status">, z.ZodObject<{
+        object: z.ZodLiteral<"commit_receipt">;
+        clientTxId: z.ZodString;
+        serverTxId: z.ZodString;
+        success: z.ZodLiteral<false>;
+        status: z.ZodLiteral<"rejected">;
+        lastSyncId: z.ZodOptional<z.ZodNumber>;
+        ops: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodObject<{
+            code: z.ZodCustom<ErrorCode, ErrorCode>;
+            message: z.ZodString;
+            field: z.ZodOptional<z.ZodString>;
+            requiredCapability: z.ZodOptional<z.ZodObject<{
+                scope: z.ZodString;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>>>;
+                issuer: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+                ttlSeconds: z.ZodPreprocess<z.ZodOptional<z.ZodNumber>>;
+                nonce: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export type MutationResultMessageWire = z.infer<typeof mutationResultMessageSchema>;
+export declare const commitExecutionResultSchema: z.ZodPipe<z.ZodObject<{
+    lastSyncId: z.ZodNumber;
+    firstSyncId: z.ZodNumber;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        confirmed: "confirmed";
+    }>>;
+    correlationId: z.ZodOptional<z.ZodString>;
+    confirmationTransactionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodTransform<{
+    status: "queued" | "confirmed";
+    lastSyncId: number;
+    firstSyncId: number;
+    correlationId?: string | undefined;
+    confirmationTransactionIds?: string[] | undefined;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+}, {
+    lastSyncId: number;
+    firstSyncId: number;
+    status?: "queued" | "confirmed" | undefined;
+    correlationId?: string | undefined;
+    confirmationTransactionIds?: string[] | undefined;
+    notifications?: {
+        model: string;
+        id: string;
+        readAt: number;
+        observedSyncId: number;
+        conflictingFields: string[];
+        currentValues: Record<string, unknown>;
+        writtenBy: {
+            kind: "user" | "agent" | "system";
+            id: string;
+        };
+        object?: "stale_notification" | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    missingIds?: string[] | undefined;
+}>>;
+export type CommitExecutionResultInput = z.input<typeof commitExecutionResultSchema>;
+export type CommitExecutionResult = z.infer<typeof commitExecutionResultSchema>;
+/** Normalized acknowledgement handed from a mutation transport to the queue. */
+export declare const commitAckSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "status">;
+export type CommitAck = z.infer<typeof commitAckSchema>;
+/**
+ * The boundary an injected mutation executor returns through. It is the
+ * acknowledgement schema itself: settlement is declared, never inferred from
+ * an omission, so a transport cannot report a write as landed by staying
+ * silent about how it landed.
+ */
+export declare const mutationCommitResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"queued">;
+    correlationId: z.ZodString;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmed">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    lastSyncId: z.ZodNumber;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>], "status">;
+export type MutationCommitResultInput = z.input<typeof mutationCommitResultSchema>;
+export type MutationCommitResult = z.infer<typeof mutationCommitResultSchema>;
+/**
+ * Public SDK projection returned by `ablo.commits` and model mutations.
+ *
+ * This intentionally does not compose `commitSettlementSchema`: on the WS
+ * facade, `wait:'queued'` currently means locally sealed/enqueued, before a
+ * server has necessarily accepted the write. Renaming that public state to
+ * `enqueued` is a separate protocol change; the authoritative settlement
+ * union above is reserved for server acknowledgements.
+ */
+export declare const clientCommitReceiptSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        confirmed: "confirmed";
+    }>;
+    lastSyncId: z.ZodOptional<z.ZodNumber>;
+    notifications: z.ZodOptional<z.ZodArray<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>>>;
+    missingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ClientCommitReceipt = z.infer<typeof clientCommitReceiptSchema>;
+/** Control fields any operation in a commit may carry. */
+export declare const commitOperationControlShape: {
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+};
+/** One write inside a commit, in the canonical spelling. */
+export declare const commitOperationBodySchema: z.ZodObject<{
+    action: z.ZodString;
+    model: z.ZodString;
+    data: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        reject: "reject";
+        overwrite: "overwrite";
+        notify: "notify";
+    }>>>;
+    fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type CommitOperationBody = z.infer<typeof commitOperationBodySchema>;
+/**
+ * The `POST /v1/commits` request body.
+ *
+ * `operations` carries the writes; `track` registers durable premises.
+ * Neither is required on its own, because a body with `track` and no
+ * `operations` is how a caller starts watching a row without writing to it.
+ * Request identity travels in the `Idempotency-Key` header.
+ */
+export declare const commitRequestSchema: z.ZodObject<{
+    operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        model: z.ZodString;
+        data: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        transactionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        readAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        onStale: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            reject: "reject";
+            overwrite: "overwrite";
+            notify: "notify";
+        }>>>;
+        fenceToken: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    reads: z.ZodOptional<z.ZodNullable<z.ZodArray<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>]>>>>;
+    track: z.ZodOptional<z.ZodNullable<z.ZodArray<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>]>>>>;
+}, z.core.$strip>;
+export type CommitRequest = z.infer<typeof commitRequestSchema>;
+//# sourceMappingURL=commit.d.ts.map

package/dist/wire/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/wire/commit.ts"],"names":[],"mappings":"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"}