@qodeca/xezar 0.10.1

package/dist/contract/github.d.ts

@@ -0,0 +1,597 @@
+import { z } from 'zod';
+/**
+ * One issue or pull request, flattened for the cockpit (`ForgeItem` server-side).
+ * A protected shape — BACKWARD_COMPATIBILITY.md §2 forbids reshaping it.
+ */
+export declare const githubItemSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        issue: "issue";
+        pr: "pr";
+    }>;
+    number: z.ZodNumber;
+    title: z.ZodString;
+    author: z.ZodString;
+    createdAt: z.ZodString;
+    labels: z.ZodArray<z.ZodString>;
+    body: z.ZodString;
+    url: z.ZodString;
+    comments: z.ZodNumber;
+    isDraft: z.ZodOptional<z.ZodBoolean>;
+    additions: z.ZodOptional<z.ZodNumber>;
+    deletions: z.ZodOptional<z.ZodNumber>;
+    checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+    }>>>;
+}, z.core.$strip>;
+export type GithubItem = z.infer<typeof githubItemSchema>;
+/**
+ * `GET /api/v1/github` — the tab's issue + PR lists.
+ *
+ * NOT a discriminated union, unlike its siblings: `fetchGithub` always answers the full record and
+ * merely flips `available`, so an unavailable payload still carries `issues: []` / `prs: []`.
+ */
+export declare const githubDataSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    syncedAt: z.ZodOptional<z.ZodString>;
+    issues: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            issue: "issue";
+            pr: "pr";
+        }>;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        author: z.ZodString;
+        createdAt: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        body: z.ZodString;
+        url: z.ZodString;
+        comments: z.ZodNumber;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
+        additions: z.ZodOptional<z.ZodNumber>;
+        deletions: z.ZodOptional<z.ZodNumber>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+    }, z.core.$strip>>;
+    prs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            issue: "issue";
+            pr: "pr";
+        }>;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        author: z.ZodString;
+        createdAt: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        body: z.ZodString;
+        url: z.ZodString;
+        comments: z.ZodNumber;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
+        additions: z.ZodOptional<z.ZodNumber>;
+        deletions: z.ZodOptional<z.ZodNumber>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+    }, z.core.$strip>>;
+    labelColors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type GithubData = z.infer<typeof githubDataSchema>;
+/**
+ * `GET /api/v1/github/checks?prs=…` (#664) — lazy PR checks glyphs, `number → glyph`. The list
+ * call no longer ships `statusCheckRollup`, so a row's glyph is hydrated here for the on-screen
+ * rows only. An absent number means "no checks / not found".
+ */
+export declare const githubChecksDataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    available: z.ZodLiteral<true>;
+    checks: z.ZodRecord<z.ZodNumber, z.ZodNullable<z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+    }>>>;
+}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, z.core.$strip>], "available">;
+export type GithubChecksData = z.infer<typeof githubChecksDataSchema>;
+/**
+ * `GET /api/v1/github/search?kind=…&q=…&limit=…` (#730) — issues/PRs in ANY state.
+ *
+ * `GET /api/v1/github` lists the OPEN set only, and the tab's search is an in-memory filter over
+ * exactly that payload, so a closed or merged item is not "outside the fetched window" — it was
+ * never fetched, and nothing the user types can reach it. This is the cross-state lookup the tab
+ * falls back to.
+ *
+ * Not a discriminated union, like `githubDataSchema` and unlike `githubChecksDataSchema`: the
+ * driver always answers the full record and merely flips `available`, so an unavailable payload
+ * still carries `items: []`.
+ */
+export declare const githubSearchDataSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            issue: "issue";
+            pr: "pr";
+        }>;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        author: z.ZodString;
+        createdAt: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        body: z.ZodString;
+        url: z.ZodString;
+        comments: z.ZodNumber;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
+        additions: z.ZodOptional<z.ZodNumber>;
+        deletions: z.ZodOptional<z.ZodNumber>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+    }, z.core.$strip>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    labelColors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type GithubSearchData = z.infer<typeof githubSearchDataSchema>;
+/**
+ * Where a referenced PR or issue STANDS — the vocabulary a task's tracker chip paints.
+ *
+ * One flat enum rather than a per-kind union, because the chip renders one status and a union
+ * would make every consumer narrow on `kind` before it could pick a color. The kinds share no
+ * value on purpose: a closed PR (abandoned — red) and a closed issue (`completed` — done, violet)
+ * are opposite outcomes wearing the same English word, and collapsing them is how a merged-looking
+ * task turns out to have been dropped.
+ *
+ * PR values: `merged`, `closed` (closed WITHOUT merging), `draft`, `checks-pending`,
+ * `changes-requested`, `checks-failing`, `review-required`, `ready`. Issue values: `open`,
+ * `completed`, `not-planned`.
+ *
+ * Which one a PR gets is `derivePrReferenceStatus`'s ranking (server-side, and documented there):
+ * it answers "what is this waiting on right now", so it ranks by how FRESH a signal is rather
+ * than by how heavy a blocker it is — running checks mean a commit was just pushed, and a
+ * requested change the author has already pushed past is not what the PR is waiting on.
+ *
+ * `ready` is the honest reading of "nothing is blocking it here": open, not a draft, no failing or
+ * running checks, and no review the forge is still waiting on. It is NOT a mergeability probe —
+ * that is `githubPrMergeStateResponseSchema`, which costs a request per PR; this is one batched
+ * query for a whole table.
+ */
+export declare const referenceStatusSchema: z.ZodEnum<{
+    "changes-requested": "changes-requested";
+    "checks-failing": "checks-failing";
+    "checks-pending": "checks-pending";
+    closed: "closed";
+    completed: "completed";
+    draft: "draft";
+    merged: "merged";
+    "not-planned": "not-planned";
+    open: "open";
+    ready: "ready";
+    "review-required": "review-required";
+}>;
+export type ReferenceStatus = z.infer<typeof referenceStatusSchema>;
+/**
+ * `GET /api/v1/github/ref-status?prs=…&issues=…` — batched status for the PR/issue chips a task
+ * table is painting. The additive sibling of `/github/checks`: same cache-behind-the-route shape,
+ * same in-payload degrade, same "absent number = nothing known" rule (an unknown or unreachable
+ * number is simply missing from the map, and its chip stays neutral).
+ */
+/**
+ * How many numbers of ONE kind a single `/github/ref-status` request may name — the route 400s
+ * past it, and the cockpit caps its batches to match.
+ *
+ * It lives in the contract because it is one: a client that believed a larger number would send
+ * requests the server rejects outright, costing every chip in the batch its status rather than
+ * just the tail. Two constants that must agree, in two packages, with nothing making them, is the
+ * drift this export exists to prevent.
+ */
+export declare const REFERENCE_STATUS_MAX = 100;
+export declare const githubRefStatusDataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    available: z.ZodLiteral<true>;
+    prs: z.ZodRecord<z.ZodNumber, z.ZodEnum<{
+        "changes-requested": "changes-requested";
+        "checks-failing": "checks-failing";
+        "checks-pending": "checks-pending";
+        closed: "closed";
+        completed: "completed";
+        draft: "draft";
+        merged: "merged";
+        "not-planned": "not-planned";
+        open: "open";
+        ready: "ready";
+        "review-required": "review-required";
+    }>>;
+    issues: z.ZodRecord<z.ZodNumber, z.ZodEnum<{
+        "changes-requested": "changes-requested";
+        "checks-failing": "checks-failing";
+        "checks-pending": "checks-pending";
+        closed: "closed";
+        completed: "completed";
+        draft: "draft";
+        merged: "merged";
+        "not-planned": "not-planned";
+        open: "open";
+        ready: "ready";
+        "review-required": "review-required";
+    }>>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    recheckAfterMs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodLiteral<false>;
+    reason: z.ZodString;
+    recheckAfterMs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>], "available">;
+export type GithubRefStatusData = z.infer<typeof githubRefStatusDataSchema>;
+/** One comment or PR review summary in an issue/PR thread (#499). */
+export declare const githubCommentSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    author: z.ZodString;
+    avatarUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    body: z.ZodString;
+    kind: z.ZodEnum<{
+        comment: "comment";
+        review: "review";
+    }>;
+    reviewState: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        changes_requested: "changes_requested";
+        commented: "commented";
+        dismissed: "dismissed";
+    }>>;
+    url: z.ZodString;
+}, z.core.$strip>;
+export type GithubComment = z.infer<typeof githubCommentSchema>;
+/**
+ * The timeline event kinds the thread renders (#525) — an allowlist, so an unknown GitHub event
+ * type is dropped server-side rather than reaching the client.
+ */
+export declare const githubTimelineEventKindSchema: z.ZodEnum<{
+    assigned: "assigned";
+    closed: "closed";
+    committed: "committed";
+    "cross-referenced": "cross-referenced";
+    head_ref_force_pushed: "head_ref_force_pushed";
+    labeled: "labeled";
+    merged: "merged";
+    renamed: "renamed";
+    reopened: "reopened";
+    unassigned: "unassigned";
+    unlabeled: "unlabeled";
+}>;
+export type GithubTimelineEventKind = z.infer<typeof githubTimelineEventKindSchema>;
+/**
+ * One non-comment timeline row (#525). Deliberately a separate shape from `GithubComment` rather
+ * than a widened `kind`, which would break the client's narrowing.
+ */
+export declare const githubTimelineEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        assigned: "assigned";
+        closed: "closed";
+        committed: "committed";
+        "cross-referenced": "cross-referenced";
+        head_ref_force_pushed: "head_ref_force_pushed";
+        labeled: "labeled";
+        merged: "merged";
+        renamed: "renamed";
+        reopened: "reopened";
+        unassigned: "unassigned";
+        unlabeled: "unlabeled";
+    }>;
+    actor: z.ZodString;
+    avatarUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    sha: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+    }>>>;
+    label: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    subject: z.ZodOptional<z.ZodString>;
+    refNumber: z.ZodOptional<z.ZodNumber>;
+    refTitle: z.ZodOptional<z.ZodString>;
+    refIsPr: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GithubTimelineEvent = z.infer<typeof githubTimelineEventSchema>;
+/**
+ * `GET /api/v1/github/comments/:kind/:number` — the full thread. Degrades to
+ * `{ available: false, reason }` like the list fetch, never an error.
+ */
+export declare const githubCommentsDataSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    comments: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        author: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        body: z.ZodString;
+        kind: z.ZodEnum<{
+            comment: "comment";
+            review: "review";
+        }>;
+        reviewState: z.ZodOptional<z.ZodEnum<{
+            approved: "approved";
+            changes_requested: "changes_requested";
+            commented: "commented";
+            dismissed: "dismissed";
+        }>>;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            assigned: "assigned";
+            closed: "closed";
+            committed: "committed";
+            "cross-referenced": "cross-referenced";
+            head_ref_force_pushed: "head_ref_force_pushed";
+            labeled: "labeled";
+            merged: "merged";
+            renamed: "renamed";
+            reopened: "reopened";
+            unassigned: "unassigned";
+            unlabeled: "unlabeled";
+        }>;
+        actor: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        sha: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+        label: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            color: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        subject: z.ZodOptional<z.ZodString>;
+        refNumber: z.ZodOptional<z.ZodNumber>;
+        refTitle: z.ZodOptional<z.ZodString>;
+        refIsPr: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GithubCommentsData = z.infer<typeof githubCommentsDataSchema>;
+export declare const githubMergeMethodSchema: z.ZodEnum<{
+    merge: "merge";
+    rebase: "rebase";
+    squash: "squash";
+}>;
+export type GithubMergeMethod = z.infer<typeof githubMergeMethodSchema>;
+/** One check row of the merge panel. */
+export declare const githubPrCheckSchema: z.ZodObject<{
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+        unknown: "unknown";
+    }>;
+    required: z.ZodNullable<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GithubPrCheck = z.infer<typeof githubPrCheckSchema>;
+/** Everything the merge panel needs about one PR. */
+export declare const githubPrMergeStateSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    title: z.ZodString;
+    url: z.ZodString;
+    state: z.ZodEnum<{
+        closed: "closed";
+        merged: "merged";
+        open: "open";
+    }>;
+    isDraft: z.ZodBoolean;
+    headRef: z.ZodString;
+    baseRef: z.ZodString;
+    headSha: z.ZodString;
+    mergeable: z.ZodEnum<{
+        conflicting: "conflicting";
+        mergeable: "mergeable";
+        unknown: "unknown";
+    }>;
+    reviewDecision: z.ZodEnum<{
+        approved: "approved";
+        "changes-requested": "changes-requested";
+        "review-required": "review-required";
+        unknown: "unknown";
+    }>;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+            unknown: "unknown";
+        }>;
+        required: z.ZodNullable<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    methods: z.ZodArray<z.ZodEnum<{
+        merge: "merge";
+        rebase: "rebase";
+        squash: "squash";
+    }>>;
+    defaultMethod: z.ZodNullable<z.ZodEnum<{
+        merge: "merge";
+        rebase: "rebase";
+        squash: "squash";
+    }>>;
+    eligibility: z.ZodEnum<{
+        blocked: "blocked";
+        pending: "pending";
+        ready: "ready";
+        terminal: "terminal";
+        unauthorized: "unauthorized";
+        unknown: "unknown";
+    }>;
+    blockers: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    canMerge: z.ZodBoolean;
+    canOverride: z.ZodBoolean;
+}, z.core.$strip>;
+export type GithubPrMergeState = z.infer<typeof githubPrMergeStateSchema>;
+/** `GET /api/v1/github/prs/:number/merge-state` — 200 either way; the reason is the degrade. */
+export declare const githubPrMergeStateResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    available: z.ZodLiteral<true>;
+    mergeState: z.ZodObject<{
+        number: z.ZodNumber;
+        title: z.ZodString;
+        url: z.ZodString;
+        state: z.ZodEnum<{
+            closed: "closed";
+            merged: "merged";
+            open: "open";
+        }>;
+        isDraft: z.ZodBoolean;
+        headRef: z.ZodString;
+        baseRef: z.ZodString;
+        headSha: z.ZodString;
+        mergeable: z.ZodEnum<{
+            conflicting: "conflicting";
+            mergeable: "mergeable";
+            unknown: "unknown";
+        }>;
+        reviewDecision: z.ZodEnum<{
+            approved: "approved";
+            "changes-requested": "changes-requested";
+            "review-required": "review-required";
+            unknown: "unknown";
+        }>;
+        checks: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            state: z.ZodEnum<{
+                failing: "failing";
+                passing: "passing";
+                pending: "pending";
+                unknown: "unknown";
+            }>;
+            required: z.ZodNullable<z.ZodBoolean>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        methods: z.ZodArray<z.ZodEnum<{
+            merge: "merge";
+            rebase: "rebase";
+            squash: "squash";
+        }>>;
+        defaultMethod: z.ZodNullable<z.ZodEnum<{
+            merge: "merge";
+            rebase: "rebase";
+            squash: "squash";
+        }>>;
+        eligibility: z.ZodEnum<{
+            blocked: "blocked";
+            pending: "pending";
+            ready: "ready";
+            terminal: "terminal";
+            unauthorized: "unauthorized";
+            unknown: "unknown";
+        }>;
+        blockers: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+        canMerge: z.ZodBoolean;
+        canOverride: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, z.core.$strip>], "available">;
+export type GithubPrMergeStateResponse = z.infer<typeof githubPrMergeStateResponseSchema>;
+/**
+ * `POST /api/v1/github/prs/:number/merge` — the 200 branch only. Every refusal (403/404/409/502)
+ * is an `ApiError`, so `merged` is pinned to `true` here rather than a boolean to re-check.
+ */
+export declare const githubMergeResponseSchema: z.ZodObject<{
+    merged: z.ZodLiteral<true>;
+    number: z.ZodNumber;
+    url: z.ZodString;
+    method: z.ZodEnum<{
+        merge: "merge";
+        rebase: "rebase";
+        squash: "squash";
+    }>;
+    mergeCommitSha: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GithubMergeResponse = z.infer<typeof githubMergeResponseSchema>;
+/** One changed file of a pull request's diff. */
+export declare const githubPrChangeSchema: z.ZodObject<{
+    path: z.ZodString;
+    previousPath: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        added: "added";
+        changed: "changed";
+        copied: "copied";
+        modified: "modified";
+        removed: "removed";
+        renamed: "renamed";
+    }>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    patch: z.ZodOptional<z.ZodString>;
+    patchUnavailableReason: z.ZodOptional<z.ZodEnum<{
+        binary: "binary";
+        "not-provided": "not-provided";
+        "too-large": "too-large";
+    }>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GithubPrChange = z.infer<typeof githubPrChangeSchema>;
+/** `GET /api/v1/github/prs/:number/changes` — bounded, read-only PR file changes. */
+export declare const githubPrChangesDataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    available: z.ZodLiteral<true>;
+    number: z.ZodNumber;
+    headSha: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        previousPath: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            added: "added";
+            changed: "changed";
+            copied: "copied";
+            modified: "modified";
+            removed: "removed";
+            renamed: "renamed";
+        }>;
+        additions: z.ZodNumber;
+        deletions: z.ZodNumber;
+        patch: z.ZodOptional<z.ZodString>;
+        patchUnavailableReason: z.ZodOptional<z.ZodEnum<{
+            binary: "binary";
+            "not-provided": "not-provided";
+            "too-large": "too-large";
+        }>>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, z.core.$strip>], "available">;
+export type GithubPrChangesData = z.infer<typeof githubPrChangesDataSchema>;

package/dist/contract/health.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+/** The agent backends a run can be dispatched to. */
+export declare const runnerSchema: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    opencode: "opencode";
+    pi: "pi";
+}>;
+export type Runner = z.infer<typeof runnerSchema>;
+/** Git facts about the project root, or `null` when it is not a repository. */
+export declare const repoInfoSchema: z.ZodObject<{
+    root: z.ZodString;
+    branch: z.ZodString;
+    remote: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RepoInfo = z.infer<typeof repoInfoSchema>;
+/** One probed CLI behind the Tools menu. */
+export declare const backendCheckSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gh: "gh";
+        git: "git";
+        opencode: "opencode";
+        pi: "pi";
+    }>;
+    available: z.ZodBoolean;
+    version: z.ZodOptional<z.ZodString>;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BackendCheck = z.infer<typeof backendCheckSchema>;
+export declare const forgeInfoSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"github">;
+    available: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ForgeInfo = z.infer<typeof forgeInfoSchema>;
+/** Server-side feature switches the cockpit reads once at boot. */
+export declare const capabilitiesSchema: z.ZodObject<{
+    localHandoff: z.ZodBoolean;
+    followups: z.ZodBoolean;
+    singleProject: z.ZodBoolean;
+    automations: z.ZodBoolean;
+    tokenMetrics: z.ZodBoolean;
+    tokenUsageMetrics: z.ZodBoolean;
+    costMetrics: z.ZodBoolean;
+}, z.core.$strip>;
+export type Capabilities = z.infer<typeof capabilitiesSchema>;
+/**
+ * `GET /api/v1/health` — the CORS-open discovery endpoint (BACKWARD_COMPATIBILITY.md §2).
+ *
+ * Additive fields only: this is the most externally-depended-on JSON in the app.
+ */
+export declare const healthResponseSchema: z.ZodObject<{
+    version: z.ZodString;
+    latestVersion: z.ZodOptional<z.ZodString>;
+    repoRoot: z.ZodString;
+    repo: z.ZodNullable<z.ZodObject<{
+        root: z.ZodString;
+        branch: z.ZodString;
+        remote: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gh: "gh";
+            git: "git";
+            opencode: "opencode";
+            pi: "pi";
+        }>;
+        available: z.ZodBoolean;
+        version: z.ZodOptional<z.ZodString>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    defaultRunner: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        opencode: "opencode";
+        pi: "pi";
+    }>;
+    forge: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"github">;
+        available: z.ZodOptional<z.ZodBoolean>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    capabilities: z.ZodObject<{
+        localHandoff: z.ZodBoolean;
+        followups: z.ZodBoolean;
+        singleProject: z.ZodBoolean;
+        automations: z.ZodBoolean;
+        tokenMetrics: z.ZodBoolean;
+        tokenUsageMetrics: z.ZodBoolean;
+        costMetrics: z.ZodBoolean;
+    }, z.core.$strip>;
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    bootProject: z.ZodString;
+}, z.core.$strip>;
+export type HealthResponse = z.infer<typeof healthResponseSchema>;