@tai42/api-client 19.3.0 → 21.0.0

package/src/schemas/fleet.ts

@@ -1,37 +1,29 @@
 /** Backend identity and worker-bus fleet/fan-out response schemas. */
 import { z } from 'zod';
 
-import { jsonValue } from './shared';
+import * as openapi from '../generated/openapi-schemas';
 
 /** `GET /api/backend` — the execution-backend identity, or the absent sentinel
  * (`present: false`, a 200) when no backend plugin is registered. Backend identity
  * is kept distinct from the fleet: the fleet doors ride the app's worker bus and
  * need no backend at all. */
-export const backendInfo = z.object({
-  present: z.boolean(),
-  backend: z.string().nullable(),
-  module: z.string().nullable(),
-});
+export const backendInfo = openapi.backendInfo;
 export type BackendInfo = z.infer<typeof backendInfo>;
 
 /** The two worker kinds that join the bus: an ASGI `serve` worker or a
  * `backend` runtime process. A drift throws `ApiSchemaError`. */
-export const workerKind = z.enum(['serve', 'backend']);
+export const workerKind = openapi.workerKind;
 export type WorkerKind = z.infer<typeof workerKind>;
 
 /** The lifecycle state a worker advertises in its presence value: `ready` once its
  * resync has converged, `resyncing` while a boot/reconnect resync runs, `recycling`
  * once it has begun a graceful self-exit. A drift throws `ApiSchemaError`. */
-export const workerState = z.enum(['ready', 'resyncing', 'recycling']);
+export const workerState = openapi.workerState;
 export type WorkerState = z.infer<typeof workerState>;
 
 /** The last op a worker applied, stamped onto its presence row after the terminal
  * reply. `outcome` is the free op-outcome string; `at` is the ISO instant it landed. */
-export const workerLastOp = z.object({
-  op: z.string(),
-  outcome: z.string(),
-  at: z.string(),
-});
+export const workerLastOp = openapi.lastOp;
 export type WorkerLastOp = z.infer<typeof workerLastOp>;
 
 /**
@@ -45,17 +37,7 @@ export type WorkerLastOp = z.infer<typeof workerLastOp>;
  * only freshness signal a client reads, never a client-side threshold; `last_op` is the
  * worker's last applied op, or `null` before it has applied one.
  */
-export const fleetWorker = z.object({
-  name: z.string(),
-  kind: workerKind,
-  pid: z.number(),
-  generation: z.number(),
-  joined_at: z.string(),
-  beat_at: z.string(),
-  state: workerState,
-  stale: z.boolean(),
-  last_op: workerLastOp.nullable(),
-});
+export const fleetWorker = openapi.workerListingRow;
 export type FleetWorker = z.infer<typeof fleetWorker>;
 
 /**
@@ -64,7 +46,7 @@ export type FleetWorker = z.infer<typeof fleetWorker>;
  * processes alike), not only backend workers. A census read that fails surfaces as a
  * loud 500, never a fabricated empty fleet.
  */
-export const fleetWorkers = z.object({ workers: z.array(fleetWorker) });
+export const fleetWorkers = openapi.workerListing;
 export type FleetWorkers = z.infer<typeof fleetWorkers>;
 
 /**
@@ -76,16 +58,7 @@ export type FleetWorkers = z.infer<typeof fleetWorkers>;
  * `recycling` is departing, `stale` is a quiet row past the freshness bound carrying no
  * convergence promise).
  */
-export const fleetOutcome = z.enum([
-  'applied',
-  'failed',
-  'missing',
-  'departed',
-  'timed_out',
-  'resyncing',
-  'recycling',
-  'stale',
-]);
+export const fleetOutcome = openapi.opOutcome;
 export type FleetOutcome = z.infer<typeof fleetOutcome>;
 
 /**
@@ -94,13 +67,7 @@ export type FleetOutcome = z.infer<typeof fleetOutcome>;
  * publisher's report text for a computed gap outcome (`missing`/`departed`/`timed_out`/
  * `resyncing`/`recycling`/`stale`). A drift throws `ApiSchemaError`.
  */
-export const fleetWorkerResult = z.object({
-  name: z.string(),
-  outcome: fleetOutcome,
-  payload: jsonValue,
-  error: z.string().nullable(),
-  detail: z.string().nullable(),
-});
+export const fleetWorkerResult = openapi.workerResult;
 export type FleetWorkerResult = z.infer<typeof fleetWorkerResult>;
 
 /**
@@ -114,13 +81,7 @@ export type FleetWorkerResult = z.infer<typeof fleetWorkerResult>;
  * reload; it is also the body the mode-wrapped {@link fleetReportFanout} carries under its
  * `fleet` / `unreachable` modes.
  */
-export const fleetResult = z.object({
-  op: z.string(),
-  reachable: z.boolean(),
-  local_only: z.boolean(),
-  results: z.array(fleetWorkerResult),
-  error: z.string().nullable(),
-});
+export const fleetResult = openapi.fleetResult;
 export type FleetResult = z.infer<typeof fleetResult>;
 
 /**
@@ -146,9 +107,48 @@ export type FleetReloadResult = z.infer<typeof fleetReloadResult>;
  * unknown-key stripping would otherwise silently drop the field, hiding a failed
  * propagation from the shared fleet-report handler. A drift throws `ApiSchemaError`.
  */
+// Hand-written: the spec publishes a fan-out as one object with optional fields; the client
+// discriminates its three modes.
+const fanoutFleetResult = openapi.fleetResult.omit({ ok: true });
 export const fleetReportFanout = z.discriminatedUnion('mode', [
   z.object({ mode: z.literal('local-only'), note: z.string() }),
-  fleetResult.extend({ mode: z.literal('fleet') }),
-  fleetResult.extend({ mode: z.literal('unreachable') }),
+  fanoutFleetResult.extend({ mode: z.literal('fleet') }),
+  fanoutFleetResult.extend({ mode: z.literal('unreachable') }),
 ]);
 export type FleetReportFanout = z.infer<typeof fleetReportFanout>;
+
+/**
+ * One worker line of a fleet recycle roll. `status` is `recycled` (confirmed on
+ * reality), `timed-out` or `failed` (the target the roll stopped at — `detail` names
+ * why), or `self-deferred` (the worker that took the change recycles itself after
+ * replying). `generation_before` is the life that was recycled.
+ */
+export const recycleEntry = openapi.recycleEntry;
+export type RecycleEntry = z.infer<typeof recycleEntry>;
+
+/** One newly-ready worker life observed since the change began — capacity evidence. */
+export const freshLife = openapi.freshLife;
+export type FreshLife = z.infer<typeof freshLife>;
+
+/**
+ * Where a recycle roll stopped and why: `name` is the target it stopped at, or `null`
+ * when the bus could not be read before a target was reached.
+ */
+export const recycleStop = openapi.recycleStop;
+export type RecycleStop = z.infer<typeof recycleStop>;
+
+/**
+ * The report of a fleet recycle roll an env change carrying a recycle-class key ran:
+ * the worker lines, the fresh lives, and where the roll stopped (`null` when it ran to
+ * its end). Names only — never an env value.
+ */
+export const recycleRoll = openapi.recycleRoll;
+export type RecycleRoll = z.infer<typeof recycleRoll>;
+
+/**
+ * One worker an operation names as still awaiting a respawn: its recycle-class `keys`
+ * changed in the stored env since its process bound them (at boot, or when the plugin that
+ * declares them was loaded), and nothing in the operation respawns it.
+ */
+export const awaitingWorker = openapi.awaitingWorker;
+export type AwaitingWorker = z.infer<typeof awaitingWorker>;

package/src/schemas/hooks.ts

@@ -1,57 +1,38 @@
 /** Hook listing, registration and topic-verifier response schemas. */
 import { z } from 'zod';
 
-import { hookParams } from './served';
+import * as openapi from '../generated/openapi-schemas';
 
-// The hand-written hook response DTOs: the fire-door authority enum, the list rows and
-// their wrapper, and the per-topic verifier/trigger metadata. The served hook DOCUMENT
-// schemas (`hookSubject`/`hookParams`/`hookRegister`) are generated from the contract
-// bundle and re-exported at the top of this file, not defined here.
+// The hook response schemas: the fire-door authority enum, the list rows and their
+// wrapper, and the per-topic verifier/trigger metadata. The served hook DOCUMENT schemas
+// (`hookSubject`/`hookParams`/`hookRegister`) are re-exported from `./served`.
 
 /** A fire door — who may trigger a path, not what the fire may do. A string enum. */
-export const triggerAuth = z.enum([
-  'public',
-  'verifier',
-  'token',
-  'token+api_key',
-  'out-of-service',
-]);
+export const triggerAuth = openapi.hookListView.shape.trigger_auth.valueType;
 export type TriggerAuth = z.infer<typeof triggerAuth>;
 
-export const hookList = z.object({
-  items: z.array(hookParams),
-  total: z.number(),
-  // Per-topic verifier bindings: the topic name maps to the verifier bound to it
-  // and that verifier's config (which carries a `secret_env` name, never a secret
-  // value). Tolerant of an older/empty response, which omits the key entirely.
-  topic_verifiers: z
-    .record(
-      z.string(),
-      z.object({ verifier: z.string(), config: z.record(z.string(), z.unknown()) }),
-    )
-    .default({}),
-  // Per-topic fire door (topic → door). Tolerant of an older response omitting it.
-  trigger_auth: z.record(z.string(), triggerAuth).default({}),
+export const hookList = openapi.hookListView.extend({
+  // Per-topic verifier bindings: the topic name maps to the verifier bound to it and that
+  // verifier's config (which carries a `secret_env` name, never a secret value). Hand-typed:
+  // the spec publishes a binding as an open value.
+  topic_verifiers: z.record(
+    z.string(),
+    z.object({ verifier: z.string(), config: z.record(z.string(), z.unknown()) }),
+  ),
 });
 export type HookList = z.infer<typeof hookList>;
 
-export const hookRegistered = z.object({
-  registered: z.boolean(),
-  name: z.string(),
-});
+export const hookRegistered = openapi.hookRegisterResult;
 
-export const hookRemoved = z.object({
-  removed: z.boolean(),
-  name: z.string(),
-});
+export const hookRemoved = openapi.removedByName;
 
 // The registered webhook-verifier catalog (`GET /api/hooks/verifiers`) — the
 // sorted verifier NAMES only, never any verifier's config. An empty registry is a
 // valid empty array. This is the ONLY source the topic-verifier bind picker reads.
-export const hookVerifiers = z.array(z.string());
+export const hookVerifiers = openapi.stringListResponse;
 
 /** `PUT /api/hooks/topics/{topic}/verifier` — the bound topic + verifier name. */
-export const topicVerifierSet = z.object({ topic: z.string(), verifier: z.string() });
+export const topicVerifierSet = openapi.topicVerifierView;
 
 /** `DELETE /api/hooks/topics/{topic}/verifier` — the unbound topic. */
-export const topicVerifierRemoved = z.object({ removed: z.boolean(), topic: z.string() });
+export const topicVerifierRemoved = openapi.removedByTopic;

package/src/schemas/index.ts

@@ -15,6 +15,7 @@ export * from './interactions';
 export * from './login';
 export * from './manifest-mcp';
 export * from './marketplace';
+export * from './members';
 export * from './notifications';
 export * from './observability';
 export * from './policy';
@@ -36,4 +37,3 @@ export * from './templates';
 export * from './tool-meta';
 export * from './tools';
 export * from './trigger-links';
-export * from './web-entry';

package/src/schemas/interactions.ts

@@ -1,69 +1,41 @@
 /** Interaction question, answer and media response schemas. */
 import { z } from 'zod';
 
-import { pageWindow } from './shared';
+import * as openapi from '../generated/openapi-schemas';
+import * as served from '../generated/served-schemas';
 
 // Shapes match the skeleton's interactions SSE contract: the SSE
 // `interaction.add` frame carries the question and its answer format; the answer
 // door returns { interaction_id, status }. `answered` is not a wire field — it
 // is a client-side flag the stream hook flips on an `interaction.answered` event.
 
-export const answerFormat = z.enum(['text', 'confirm', 'select', 'form', 'external']);
+export const answerFormat = openapi.answerFormat;
 export type AnswerFormat = z.infer<typeof answerFormat>;
 
-/** The kind of a question's display-only media item: a remote/inline image, or a link. */
-export const mediaKind = z.enum(['image', 'link']);
+/** The kind of a display-only media item: an image, a link, or a document, video or audio file. */
+export const mediaKind = openapi.mediaKind;
 export type MediaKind = z.infer<typeof mediaKind>;
 
 /**
- * One item of a question's display-only media. Applied PER ITEM by the renderer
- * (never as a strict array on the frame): the frame's `media` field is a loose
- * `z.array(z.unknown())`, and the renderer `safeParse`s each item with this schema
- * so one malformed/hostile item is a loud per-item notice, not a whole-frame parse
- * failure that would silently vanish an answerable question.
- *
- * `caption` is `.nullish()` (absent OR `null` both parse to a caption-less item):
- * a caption-less item may arrive with the key omitted OR with an explicit `null`, so
- * `.optional()` here would false-fail the explicit `null` and render a good image as
- * malformed. `url` and `kind` are the only load-bearing fields; the image
- * src scheme gate and the link neutralization are enforced by the renderer.
+ * One item of a question's display-only media. The renderer resolves `url` (the image src
+ * scheme gate and the link neutralization are enforced there); `caption` and `filename`
+ * are `null` when absent.
  */
-export const interactionMediaItem = z.object({
-  kind: mediaKind,
-  url: z.string(),
-  caption: z.string().nullish(),
-});
+export const interactionMediaItem = openapi.mediaItem;
 export type InteractionMediaItem = z.infer<typeof interactionMediaItem>;
 
-/**
- * The kind of a byte-backed inbound attachment carried on a transcript record. A
- * fetchable file — `image`/`document`/`audio`/`video` — never a `link`: a labelled
- * anchor is question CONTEXT (see {@link mediaKind}), not a participant's sent file.
- */
-export const attachmentMediaKind = z.enum(['image', 'document', 'audio', 'video']);
+/** The kind of an inbound attachment carried on a transcript record. */
+export const attachmentMediaKind = openapi.mediaKind;
 export type AttachmentMediaKind = z.infer<typeof attachmentMediaKind>;
 
 /**
  * One inbound attachment a participant sent, projected onto a transcript record's
- * `inbound_attachments`. Applied PER ITEM by the renderer (the record's array is a
- * loose `z.array(z.unknown())`, `safeParse`d per member) so one malformed/hostile
- * item is a loud per-item notice, never a whole-record parse failure that would
- * vanish the transcript.
- *
- * `url` is the served-media reference the renderer resolves to the API origin (the
- * same served-url discipline the ask-media renderer uses); the image src scheme gate
- * and the per-item load-failure notice are enforced there. `caption` and `filename`
- * are `.nullish()` (absent OR explicit `null` both parse to absent): the projection
- * may omit the key OR emit `null`, so `.optional()` alone would false-fail an explicit
- * `null`. `filename` is meaningful only for a `document`; the renderer shows it as the
- * download label.
+ * `inbound_attachments`. `url` is the served-media reference the renderer resolves to the
+ * API origin (the same served-url discipline the ask-media renderer uses); the image src
+ * scheme gate and the per-item load-failure notice are enforced there. `filename` is
+ * meaningful only for a `document`; the renderer shows it as the download label.
  */
-export const attachmentMediaItem = z.object({
-  kind: attachmentMediaKind,
-  url: z.string(),
-  caption: z.string().nullish(),
-  filename: z.string().nullish(),
-});
+export const attachmentMediaItem = openapi.mediaItem;
 export type AttachmentMediaItem = z.infer<typeof attachmentMediaItem>;
 
 /**
@@ -73,10 +45,7 @@ export type AttachmentMediaItem = z.infer<typeof attachmentMediaItem>;
  * `enum` this way for one ask without republishing the form. Applied per property by
  * the form preview (safeParsed), so a malformed entry is a loud notice, never silent.
  */
-export const formOption = z.object({
-  value: z.string(),
-  label: z.string().nullish(),
-});
+export const formOption = openapi.formOption;
 export type FormOption = z.infer<typeof formOption>;
 
 /**
@@ -85,14 +54,11 @@ export type FormOption = z.infer<typeof formOption>;
  * default to empty. The form preview safeParses this off `format_payload.data`, so a
  * malformed block is a loud notice rather than a whole-frame parse failure.
  */
-export const formData = z.object({
-  values: z.record(z.string(), z.unknown()).default({}),
-  options: z.record(z.string(), z.array(formOption)).default({}),
-});
+export const formData = openapi.formData;
 export type FormData = z.infer<typeof formData>;
 
 /** The kind of an ordered display block a page may carry alongside its input fields. */
-export const displayBlockKind = z.enum(['heading', 'body', 'image']);
+export const displayBlockKind = openapi.displayBlock.shape.kind;
 export type DisplayBlockKind = z.infer<typeof displayBlockKind>;
 
 /**
@@ -106,17 +72,11 @@ export type DisplayBlockKind = z.infer<typeof displayBlockKind>;
  * whole-page parse failure. Applied per block by the preview (safeParsed via its page),
  * so a malformed block is a loud notice, never silent.
  */
-export const displayBlock = z.object({
-  kind: displayBlockKind,
-  text: z.string().nullish(),
-  src: z.string().nullish(),
-  alt: z.string().nullish(),
-  slot: z.string().nullish(),
-});
+export const displayBlock = openapi.displayBlock;
 export type DisplayBlock = z.infer<typeof displayBlock>;
 
 /** A page's role: an ordinary `input` page (default) or a terminal `review` summary. */
-export const formPageKind = z.enum(['input', 'review']);
+export const formPageKind = openapi.formPage.shape.kind.unwrap();
 export type FormPageKind = z.infer<typeof formPageKind>;
 
 /**
@@ -131,18 +91,16 @@ export type FormPageKind = z.infer<typeof formPageKind>;
  * and carries no new input fields; it defaults to `input`. Both are additive: an older
  * payload ({title, fields}) parses unchanged.
  */
-export const formPage = z.object({
-  title: z.string(),
-  fields: z.array(z.string()),
-  display: z.array(displayBlock).default([]),
-  kind: formPageKind.default('input'),
-});
+export const formPage = openapi.formPage;
 export type FormPage = z.infer<typeof formPage>;
 
 /** The `form` pages list (`format_payload.pages`), safeParsed as a whole by the preview. */
 export const formPages = z.array(formPage);
 export type FormPages = z.infer<typeof formPages>;
 
+// The form reactions and the form update are hand-written: the spec carries them inside an
+// open `format_payload` and an open reaction `update`.
+
 /**
  * When a `form` reacts while it is open (`format_payload.reactions`): the plain,
  * renderer-readable description of WHEN the form calls its reaction handler. Absent ⇒ a
@@ -163,12 +121,12 @@ export const formReactions = z.object({
 export type FormReactions = z.infer<typeof formReactions>;
 
 /**
- * The form update a reaction door returns (`POST /api/interactions/{id}/react`): the
- * same kind of data a form is sent with, applied to the open form. `values` sets field
- * values; `options` replaces the per-send choice list of option-bearing fields; `errors`
- * shows per-field messages (keyed by field name); `display` fills display slots (keyed by
- * slot name) — a computed total among them. Every member defaults to empty, so a reaction
- * that touches only one of them returns only that one. The door response is safeParsed, so
+ * The form update a reaction door returns (`POST /api/interactions/{id}/react`, its
+ * `update`): the same kind of data a form is sent with, applied to the open form. `values`
+ * sets field values; `options` replaces the per-send choice list of option-bearing fields;
+ * `errors` shows per-field messages (keyed by field name); `display` fills display slots
+ * (keyed by slot name) — a computed total among them. Every member defaults to empty, so a
+ * reaction that touches only one of them returns only that one. The door response is safeParsed, so
  * a malformed update surfaces loudly rather than applying a half-understood change.
  */
 export const formUpdate = z.object({
@@ -180,68 +138,33 @@ export const formUpdate = z.object({
 export type FormUpdate = z.infer<typeof formUpdate>;
 
 /**
- * The event a reaction round-trip reports to the door: `kind` is which of the three
- * declared events fired, `field` names the changed field for a `field_changed` event, and
- * `page` names the advanced-from page (by title) for a `page_advanced` event. A
- * `submitted` event carries neither. The body also carries the partial `values` filled so
- * far (see {@link interactionsClient}'s `reactInteraction`).
+ * The event a reaction round-trip reports to the door (the contract's `FormReactionEvent`
+ * document): `kind` is which of the three declared events fired, `field` names the changed
+ * field for a `field_changed` event, and `page` names the advanced-from page (by title) for a
+ * `page_advanced` event. A `submitted` event carries neither. The body also carries the
+ * partial `values` filled so far (see {@link interactionsClient}'s `reactInteraction`).
  */
-export const reactionEventKind = z.enum(['field_changed', 'page_advanced', 'submitted']);
-export type ReactionEventKind = z.infer<typeof reactionEventKind>;
-
-export const reactionEvent = z.object({
-  kind: reactionEventKind,
-  field: z.string().optional(),
-  page: z.string().optional(),
-});
+export const reactionEvent = served.formReactionEvent;
 export type ReactionEvent = z.infer<typeof reactionEvent>;
+export type ReactionEventKind = ReactionEvent['kind'];
 
-export const interaction = z.object({
-  interaction_id: z.string(),
-  group_id: z.string(),
-  question: z.string().default(''),
-  answer_format: answerFormat,
-  // Format-specific payload: select options, form JSON schema (with optional per-send
-  // `data` and `pages`), external url. The wire sends `null` for formats that carry
+/** The reaction door's reply: the interaction id and the form `update` to apply. */
+export const interactionReaction = openapi.interactionReactionResult.extend({ update: formUpdate });
+export type InteractionReaction = z.infer<typeof interactionReaction>;
+
+export const interaction = openapi.interactionFrame.extend({
+  // Hand-written: the format-specific payload (select options, form JSON schema with
+  // optional per-send `data` and `pages`, external url) is `null` for formats that carry
   // none (text/confirm); it is normalized to `{}` so consumers always see an object.
   format_payload: z
     .record(z.string(), z.unknown())
     .nullish()
     .transform((value) => value ?? {}),
-  created_at: z.string(),
-  timeout_at: z.string(),
-  // Whether the answer body is sensitive and never persisted server-side. Rides
-  // every add frame; an absent value (older frame) normalizes to false.
-  sensitive: z.boolean().default(false),
-  // True only for an external question answered by a signed server-to-server
-  // callback (never by a human); the frame never carries the verifier object.
-  // Absent/undefined for every other question.
-  server_verified: z.boolean().optional(),
-  // Name of the channel plugin the question was also delivered through (e.g.
-  // "telegram"); absent when the question lives only in this inbox.
-  channel: z.string().optional(),
-  // Interaction attribution, each additive and absent when unset. `recipient` is
-  // the channel delivery address the question went to; `origin` is the run id of
-  // the background tool run that asked; `audience` is the user_id the question is
-  // addressed to. Display/binding data only, never an authorization axis; a
-  // present non-string is malformed.
-  recipient: z.string().optional(),
-  origin: z.string().optional(),
-  audience: z.string().optional(),
-  // Display-only media shown WITH the question (images and/or links). Absent when
-  // the question carries none. Deliberately LOOSE (`z.array(z.unknown())`): each
-  // item is `safeParse`d per item by the renderer against `interactionMediaItem`,
-  // so one malformed/hostile item can never fail the whole frame parse and hide an
-  // answerable question. A present non-array value is still malformed.
-  media: z.array(z.unknown()).optional(),
 });
 export type Interaction = z.infer<typeof interaction>;
 
 /** The answer door's response — the blocked caller was woken. */
-export const interactionAnswered = z.object({
-  interaction_id: z.string(),
-  status: z.string(),
-});
+export const interactionAnswered = openapi.interactionActionResult;
 export type InteractionAnswered = z.infer<typeof interactionAnswered>;
 
 /**
@@ -250,10 +173,7 @@ export type InteractionAnswered = z.infer<typeof interactionAnswered>;
  * answer door's terminal reply, but the door is distinct so it carries its own
  * schema.
  */
-export const interactionCancelled = z.object({
-  interaction_id: z.string(),
-  status: z.string(),
-});
+export const interactionCancelled = openapi.interactionActionResult;
 export type InteractionCancelled = z.infer<typeof interactionCancelled>;
 
 /**
@@ -261,8 +181,5 @@ export type InteractionCancelled = z.infer<typeof interactionCancelled>;
  * item is the same record the stream's `interaction.add` frame carries. The pending
  * set is the paged base the tail-only stream applies live deltas over.
  */
-export const interactionsPage = z.object({
-  items: z.array(interaction),
-  ...pageWindow,
-});
+export const interactionsPage = openapi.interactionWindow.extend({ items: z.array(interaction) });
 export type InteractionsPage = z.infer<typeof interactionsPage>;

package/src/schemas/login.ts

@@ -1,67 +1,36 @@
 /** Public login-method aggregator and login-result schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
+
+import * as openapi from '../generated/openapi-schemas';
 
 /**
  * One field of a `form` login method. `secret` fields render as password
  * inputs; `autocomplete` passes through to the input (e.g. "email",
  * "current-password", "new-password").
  */
-export const loginFormField = z.object({
-  name: z.string().min(1),
-  label: z.string().min(1),
-  secret: z.boolean(),
-  autocomplete: z.string().optional(),
-});
+export const loginFormField = openapi.formField;
 
 /**
  * The two — and only two — login-method shapes. Discriminated on `shape`; an
  * unknown shape fails validation loudly (contract drift, not a soft skip).
- * Optional fields are `.optional()` (absent), never `.nullable()`: the server
- * serializes with `exclude_none`, so an absent field is OMITTED, never `null`.
  */
-export const loginMethod = z.discriminatedUnion('shape', [
-  z.object({
-    shape: z.literal('form'),
-    id: z.string().min(1),
-    title: z.string().min(1),
-    purpose: z.enum(['login', 'invite']).default('login'),
-    fields: z.array(loginFormField).min(1),
-    submit_path: z.string().min(1),
-  }),
-  z.object({
-    shape: z.literal('button'),
-    id: z.string().min(1),
-    label: z.string().min(1),
-    icon: z.string().optional(),
-    href: z.string().min(1),
-  }),
-]);
+export const loginMethod = openapi.loginMethodsListing.shape.methods.element;
 
 /**
  * `GET /api/login/methods` (PUBLIC). `needs_setup: true` ⇒ no principal exists
  * yet, so the deployment must be initialized through the setup door before anyone
  * can sign in. `setup_login` names the login-credential kinds the setup door can
- * attach the owner's login with; it is `null`/absent when no login-attaching
- * accounts provider is configured (a keys-only deployment). Non-strict — the
- * skeleton may grow additive fields.
+ * attach the owner's login with; it is `null` when no login-attaching accounts
+ * provider is configured (a keys-only deployment). `claim_fragment_key` names the
+ * URL-fragment key a claim link carries its token under.
  */
-export const loginMethods = z.object({
-  methods: z.array(loginMethod),
-  needs_setup: z.boolean(),
-  setup_login: z
-    .object({ kinds: z.array(z.enum(['password', 'invite'])) })
-    .nullable()
-    .optional(),
-});
+export const loginMethods = openapi.loginMethodsListing;
 
 /**
  * A successful login/exchange: the minted session token (opaque, `tai-sess-`
  * prefixed — the client treats it as an opaque string) + its user.
  */
-export const loginResult = z.object({
-  token: z.string().min(1),
-  user_id: z.string().min(1),
-});
+export const loginResult = openapi.claimExchangeResult;
 
 export type LoginFormField = z.infer<typeof loginFormField>;
 export type LoginMethod = z.infer<typeof loginMethod>;