@wjarka/cezarion 0.10.0-pr30.54

package/dist/contract/events.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+/**
+ * SSE frame payloads — the only shapes in this contract that are NOT derived from a route.
+ *
+ * They are delivered over `text/event-stream` (`GET /api/v1/runs/:id/events`, `/api/v1/events`,
+ * `/api/v1/workspace/events`), which Hono types as a string body, so `InferResponseType` sees a
+ * stream of text and never the frame inside it. That makes the route-parity check in
+ * `contract-parity*.test.ts` inapplicable here — but it is no reason to hand-write the TYPE.
+ * These are zod like everything else, and `api-types.test.ts` still pins `RunEvent` against the
+ * server's own declaration, which is the closest thing to a route that exists for it.
+ */
+/**
+ * One line of a run transcript.
+ *
+ * Open by design: `type` is a plain string and unknown keys pass through, because the event
+ * vocabulary is an APPEND-ONLY on-disk format (BACKWARD_COMPATIBILITY.md §7) that old NDJSON
+ * recordings must keep replaying forever. Closing this schema would make a recording written by
+ * a newer cezar unreadable by an older one — the opposite of what the format promises.
+ */
+export declare const runEventSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    stepId: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+}, z.core.$loose>;
+export type RunEvent = z.infer<typeof runEventSchema>;
+/** Fixed protocol-level item count for one progressive transcript page. */
+export declare const RUN_HISTORY_PAGE_ITEMS = 100;
+export declare const runIdParamSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type RunIdParam = z.infer<typeof runIdParamSchema>;
+/** Opaque, short-lived cursor returned by the history API. */
+export declare const runHistoryCursorSchema: z.ZodString;
+export type RunHistoryCursor = z.infer<typeof runHistoryCursorSchema>;
+/** Query accepted by the reverse-paged history endpoint. */
+export declare const runHistoryQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunHistoryQuery = z.infer<typeof runHistoryQuerySchema>;
+/** Additive resume controls for the existing per-run SSE endpoint. */
+export declare const runEventsQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    afterSeq: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type RunEventsQuery = z.infer<typeof runEventsQuerySchema>;
+/**
+ * Persisted history retains the append-only event vocabulary. The required envelope stays
+ * strict; additive payload keys remain open for newer protocol events, matching `RunEvent`.
+ * `z.any()` is deliberate here: Hono recursively rewrites `unknown` to its JSON union in a
+ * response type, making the schema wider than the route even though every value came from
+ * `JSON.parse`; `any` is stable on both sides while the required keys remain exact.
+ */
+export declare const runHistoryEventSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    stepId: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+}, z.core.$catchall<z.ZodAny>>;
+export type RunHistoryEvent = z.infer<typeof runHistoryEventSchema>;
+export declare const runHistoryPageSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>>;
+    itemCount: z.ZodNumber;
+    olderCursor: z.ZodOptional<z.ZodString>;
+    newerCursor: z.ZodOptional<z.ZodString>;
+    liveCursor: z.ZodString;
+    asOfSeq: z.ZodNumber;
+    hasOlder: z.ZodBoolean;
+}, z.core.$strip>;
+export type RunHistoryPage = z.infer<typeof runHistoryPageSchema>;
+export declare const runHistoryContextSchema: z.ZodObject<{
+    contextEvents: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>>;
+    asOfSeq: z.ZodNumber;
+}, z.core.$strip>;
+export type RunHistoryContext = z.infer<typeof runHistoryContextSchema>;
+/**
+ * One `checkout-progress` workspace frame (multi-project spec, step 4.3).
+ *
+ * `cloning` carries a single line of `git clone` output; `done` and `error` are terminal. The
+ * clone dialog renders `error` VERBATIM — a clone fails for reasons (auth, network, a mistyped
+ * repo) that only the server can name.
+ */
+export declare const checkoutProgressEventSchema: z.ZodObject<{
+    checkoutId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        cloning: "cloning";
+        done: "done";
+        error: "error";
+    }>;
+    line: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CheckoutProgressEvent = z.infer<typeof checkoutProgressEventSchema>;

package/dist/contract/github.d.ts

@@ -0,0 +1,556 @@
+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>;
+/**
+ * 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>;