@fuzdev/fuz_gitops 0.78.0 → 0.79.0

package/dist/repos_status.d.ts

@@ -0,0 +1,3340 @@
+/**
+ * Zod schemas for the `repos status --json` document, the report the Rust
+ * `repos` tool (`crates/fuz_repos`) prints, and the error document it prints
+ * in place of the report on a fatal error.
+ *
+ * The schemas mirror the Rust types by hand, each named as its Rust type
+ * prefixed `Repos` (`EntryStatus` is `ReposEntryStatus`), with fields as
+ * serde writes them: snake_case, a tagged enum as an object whose `kind`
+ * names its variant, an `Option` as `null` (never omitted), counts as
+ * integers, and times as unix seconds. A flattened enum's `kind`
+ * and payload sit beside its struct's own fields, so those structs are
+ * unions here (`ReposUnregisteredClone`, `ReposStatusErrorBody`) — or, for
+ * an enum with no payloads, an object whose `kind` is an enum
+ * (`ReposProbeError`). Where a
+ * Rust enum holds variants the status document never carries, the mirror
+ * leaves them out: `ReposFetchFailure` has no push rejection, and
+ * `ReposStatusErrorBody` holds only the errors `repos status --json` can
+ * print.
+ *
+ * Every object is strict and every union closed, so a field or variant the
+ * mirror doesn't know fails the parse. The Rust side bumps `version` on any
+ * change to the document's shape; a consumer checks it first, and on a
+ * mismatch reports both versions and how to install the binary this repo
+ * builds (`cargo install --path crates/fuz_repos --locked`) rather than a
+ * parse error.
+ *
+ * Drift is caught by the golden fixtures: a Rust test writes every status
+ * document shape to `src/test/fixtures/repos_status/`, covering every
+ * variant the status report and its error document can hold, and a TS test
+ * parses each with these schemas. The field semantics live in the Rust
+ * rustdoc and the JSON contract in `docs/repos.md`. The `repos sync --json`
+ * and `repos push --json` documents have no TS consumer and aren't
+ * mirrored here.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/**
+ * The `repos status --json` document's format version, Rust's
+ * `STATUS_FORMAT_VERSION`: the one these schemas parse.
+ */
+export declare const REPOS_STATUS_FORMAT_VERSION = 18;
+/** Where a live Claude Code session was recorded. */
+export declare const ReposSessionSource: z.ZodEnum<{
+    session_file: "session_file";
+    roster_worker: "roster_worker";
+}>;
+export type ReposSessionSource = z.infer<typeof ReposSessionSource>;
+/** A live Claude Code session: its process, and where it works. */
+export declare const ReposSession: z.ZodObject<{
+    pid: z.ZodNumber;
+    cwd: z.ZodString;
+    worktree: z.ZodNullable<z.ZodString>;
+    process_cwd: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        session_file: "session_file";
+        roster_worker: "roster_worker";
+    }>;
+}, z.core.$strict>;
+export type ReposSession = z.infer<typeof ReposSession>;
+/** Why busy detection can't vouch for every live session. */
+export declare const ReposUnavailable: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"home_unknown">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"relative_config_dir">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unreadable">;
+    path: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unparseable">;
+    path: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"foreign_pid_domain">;
+    path: z.ZodString;
+    pid_domain: z.ZodString;
+    source: z.ZodEnum<{
+        session_file: "session_file";
+        roster_worker: "roster_worker";
+    }>;
+}, z.core.$strict>], "kind">;
+export type ReposUnavailable = z.infer<typeof ReposUnavailable>;
+/** Busy detection as the report carries it. */
+export declare const ReposSessions: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"available">;
+    unscoped: z.ZodArray<z.ZodObject<{
+        pid: z.ZodNumber;
+        cwd: z.ZodString;
+        worktree: z.ZodNullable<z.ZodString>;
+        process_cwd: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            session_file: "session_file";
+            roster_worker: "roster_worker";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unavailable">;
+    reason: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"home_unknown">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"relative_config_dir">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unreadable">;
+        path: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unparseable">;
+        path: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"foreign_pid_domain">;
+        path: z.ZodString;
+        pid_domain: z.ZodString;
+        source: z.ZodEnum<{
+            session_file: "session_file";
+            roster_worker: "roster_worker";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">;
+export type ReposSessions = z.infer<typeof ReposSessions>;
+/** Which registry table an entry comes from. */
+export declare const ReposEntryKind: z.ZodEnum<{
+    repo: "repo";
+    reference: "reference";
+}>;
+export type ReposEntryKind = z.infer<typeof ReposEntryKind>;
+/** A repo's declared visibility on its host. */
+export declare const ReposVisibility: z.ZodEnum<{
+    private: "private";
+    public: "public";
+}>;
+export type ReposVisibility = z.infer<typeof ReposVisibility>;
+/** A repo's list of the sibling checkouts it uses. */
+export declare const ReposCheckoutList: z.ZodEnum<{
+    requires: "requires";
+    consults: "consults";
+}>;
+export type ReposCheckoutList = z.infer<typeof ReposCheckoutList>;
+/** An entry by table and key. */
+export declare const ReposEntryName: z.ZodObject<{
+    kind: z.ZodEnum<{
+        repo: "repo";
+        reference: "reference";
+    }>;
+    key: z.ZodString;
+}, z.core.$strict>;
+export type ReposEntryName = z.infer<typeof ReposEntryName>;
+/** A registry integrity rule broken. */
+export declare const ReposRegistryIssue: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"repo_not_owned">;
+    key: z.ZodString;
+    account: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork_not_owned">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"dir_not_a_name">;
+    entry: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repo: "repo";
+            reference: "reference";
+        }>;
+        key: z.ZodString;
+    }, z.core.$strict>;
+    dir: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"dir_claimed_twice">;
+    dir: z.ZodString;
+    first: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repo: "repo";
+            reference: "reference";
+        }>;
+        key: z.ZodString;
+    }, z.core.$strict>;
+    second: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repo: "repo";
+            reference: "reference";
+        }>;
+        key: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"key_in_both">;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"key_is_other_dir">;
+    key: z.ZodString;
+    entry: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repo: "repo";
+            reference: "reference";
+        }>;
+        key: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown_checkout_ref">;
+    key: z.ZodString;
+    field: z.ZodEnum<{
+        requires: "requires";
+        consults: "consults";
+    }>;
+    target: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"self_ref">;
+    key: z.ZodString;
+    field: z.ZodEnum<{
+        requires: "requires";
+        consults: "consults";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"requires_and_consults">;
+    key: z.ZodString;
+    target: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ReposRegistryIssue = z.infer<typeof ReposRegistryIssue>;
+/** What holds a branch's action back. */
+export declare const ReposBranchHold: z.ZodEnum<{
+    entry: "entry";
+    pinned: "pinned";
+    push_url: "push_url";
+    fetch_failed: "fetch_failed";
+    dirty_checkout: "dirty_checkout";
+    unprobed_worktree: "unprobed_worktree";
+    several_checkouts: "several_checkouts";
+    busy: "busy";
+    busy_unknown: "busy_unknown";
+}>;
+export type ReposBranchHold = z.infer<typeof ReposBranchHold>;
+/** What holds a reference's refresh back. */
+export declare const ReposRefreshHold: z.ZodEnum<{
+    entry: "entry";
+    pinned: "pinned";
+    origin_not_https: "origin_not_https";
+}>;
+export type ReposRefreshHold = z.infer<typeof ReposRefreshHold>;
+/** What holds a missing entry's clone back. */
+export declare const ReposCloneHold: z.ZodEnum<{
+    entry: "entry";
+    unprobed_worktree: "unprobed_worktree";
+    busy: "busy";
+}>;
+export type ReposCloneHold = z.infer<typeof ReposCloneHold>;
+/** What a run does about refreshing a third-party reference or a pin. */
+export declare const ReposRefreshVerdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"act">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"held">;
+    by: z.ZodEnum<{
+        entry: "entry";
+        pinned: "pinned";
+        origin_not_https: "origin_not_https";
+    }>;
+}, z.core.$strict>], "kind">;
+export type ReposRefreshVerdict = z.infer<typeof ReposRefreshVerdict>;
+/** Whether a repo is at the entry's dir. */
+export declare const ReposPresence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"present">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"not_a_repo">;
+}, z.core.$strict>], "kind">;
+export type ReposPresence = z.infer<typeof ReposPresence>;
+/** How sync would clone a missing entry. */
+export declare const ReposCloneRecipe: z.ZodObject<{
+    url: z.ZodString;
+    branch: z.ZodNullable<z.ZodString>;
+    shallow: z.ZodBoolean;
+    sparse: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ReposCloneRecipe = z.infer<typeof ReposCloneRecipe>;
+/** What sync does about a missing entry: clone it, or why not yet. */
+export declare const ReposCloneVerdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"act">;
+    recipe: z.ZodObject<{
+        url: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        shallow: z.ZodBoolean;
+        sparse: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"held">;
+    recipe: z.ZodObject<{
+        url: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        shallow: z.ZodBoolean;
+        sparse: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    by: z.ZodEnum<{
+        entry: "entry";
+        unprobed_worktree: "unprobed_worktree";
+        busy: "busy";
+    }>;
+}, z.core.$strict>], "kind">;
+export type ReposCloneVerdict = z.infer<typeof ReposCloneVerdict>;
+/** A sync action on a branch. */
+export declare const ReposSyncAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"push">;
+    commits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fast_forward">;
+    commits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"move">;
+}, z.core.$strict>], "kind">;
+export type ReposSyncAction = z.infer<typeof ReposSyncAction>;
+/** Why a branch is left to a person. */
+export declare const ReposBranchNeedsHuman: z.ZodEnum<{
+    diverged: "diverged";
+    unmapped: "unmapped";
+    archived_ahead: "archived_ahead";
+    shallow_local_work: "shallow_local_work";
+    upstream_not_a_branch: "upstream_not_a_branch";
+}>;
+export type ReposBranchNeedsHuman = z.infer<typeof ReposBranchNeedsHuman>;
+/** Why a branch reads as cleanup. */
+export declare const ReposCleanupReason: z.ZodEnum<{
+    merged: "merged";
+    upstream_gone: "upstream_gone";
+}>;
+export type ReposCleanupReason = z.infer<typeof ReposCleanupReason>;
+/** What sync does about a branch. */
+export declare const ReposVerdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"quiet">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"act">;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"push">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fast_forward">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"move">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"held">;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"push">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fast_forward">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"move">;
+    }, z.core.$strict>], "kind">;
+    by: z.ZodEnum<{
+        entry: "entry";
+        pinned: "pinned";
+        push_url: "push_url";
+        fetch_failed: "fetch_failed";
+        dirty_checkout: "dirty_checkout";
+        unprobed_worktree: "unprobed_worktree";
+        several_checkouts: "several_checkouts";
+        busy: "busy";
+        busy_unknown: "busy_unknown";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"needs_human">;
+    reason: z.ZodEnum<{
+        diverged: "diverged";
+        unmapped: "unmapped";
+        archived_ahead: "archived_ahead";
+        shallow_local_work: "shallow_local_work";
+        upstream_not_a_branch: "upstream_not_a_branch";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"local_only">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"cleanup">;
+    reason: z.ZodEnum<{
+        merged: "merged";
+        upstream_gone: "upstream_gone";
+    }>;
+    removable_worktree: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type ReposVerdict = z.infer<typeof ReposVerdict>;
+/** A clone's shape: shallow, sparse, or partial. */
+export declare const ReposLayout: z.ZodObject<{
+    shallow: z.ZodBoolean;
+    sparse: z.ZodBoolean;
+    partial_filter: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ReposLayout = z.infer<typeof ReposLayout>;
+/**
+ * A checkout's HEAD: a probed checkout's, an unprobed worktree's, or an
+ * unlisted git dir's — the last two `null` when it can't be read.
+ */
+export declare const ReposHead: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"branch">;
+    name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"detached">;
+    commit: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ReposHead = z.infer<typeof ReposHead>;
+/** A checkout's uncommitted work, by kind. */
+export declare const ReposUncommitted: z.ZodObject<{
+    staged: z.ZodNumber;
+    unstaged: z.ZodNumber;
+    untracked: z.ZodNumber;
+    conflicted: z.ZodNumber;
+}, z.core.$strict>;
+export type ReposUncommitted = z.infer<typeof ReposUncommitted>;
+/** A git operation in progress. */
+export declare const ReposInProgressOp: z.ZodEnum<{
+    rebase: "rebase";
+    merge: "merge";
+    cherry_pick: "cherry_pick";
+    revert: "revert";
+    bisect: "bisect";
+    sequencer: "sequencer";
+    am: "am";
+}>;
+export type ReposInProgressOp = z.infer<typeof ReposInProgressOp>;
+/** One checkout of a repo: its primary, or a linked worktree probed. */
+export declare const ReposCheckout: z.ZodObject<{
+    path: z.ZodString;
+    primary: z.ZodBoolean;
+    head: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"branch">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"detached">;
+        commit: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    uncommitted: z.ZodObject<{
+        staged: z.ZodNumber;
+        unstaged: z.ZodNumber;
+        untracked: z.ZodNumber;
+        conflicted: z.ZodNumber;
+    }, z.core.$strict>;
+    in_progress: z.ZodNullable<z.ZodEnum<{
+        rebase: "rebase";
+        merge: "merge";
+        cherry_pick: "cherry_pick";
+        revert: "revert";
+        bisect: "bisect";
+        sequencer: "sequencer";
+        am: "am";
+    }>>;
+    locked: z.ZodBoolean;
+    linked: z.ZodBoolean;
+    submodules: z.ZodNullable<z.ZodBoolean>;
+    busy: z.ZodArray<z.ZodObject<{
+        pid: z.ZodNumber;
+        cwd: z.ZodString;
+        worktree: z.ZodNullable<z.ZodString>;
+        process_cwd: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            session_file: "session_file";
+            roster_worker: "roster_worker";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReposCheckout = z.infer<typeof ReposCheckout>;
+/** A branch's relation to its upstream. */
+export declare const ReposRelation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"in_sync">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"ahead">;
+    commits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"behind">;
+    commits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"diverged">;
+    ahead: z.ZodNumber;
+    behind: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"shallow">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"gone">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unmapped">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"untracked">;
+}, z.core.$strict>], "kind">;
+export type ReposRelation = z.infer<typeof ReposRelation>;
+/** One local branch and its verdict. */
+export declare const ReposBranchStatus: z.ZodObject<{
+    name: z.ZodString;
+    upstream: z.ZodNullable<z.ZodString>;
+    worktree: z.ZodNullable<z.ZodString>;
+    symref: z.ZodNullable<z.ZodString>;
+    unique_commits: z.ZodNumber;
+    newest_commit_at: z.ZodNumber;
+    relation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"in_sync">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"ahead">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"behind">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"diverged">;
+        ahead: z.ZodNumber;
+        behind: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"shallow">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"gone">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unmapped">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"untracked">;
+    }, z.core.$strict>], "kind">;
+    verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"quiet">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"act">;
+        action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"push">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fast_forward">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"move">;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"held">;
+        action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"push">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fast_forward">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"move">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodEnum<{
+            entry: "entry";
+            pinned: "pinned";
+            push_url: "push_url";
+            fetch_failed: "fetch_failed";
+            dirty_checkout: "dirty_checkout";
+            unprobed_worktree: "unprobed_worktree";
+            several_checkouts: "several_checkouts";
+            busy: "busy";
+            busy_unknown: "busy_unknown";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"needs_human">;
+        reason: z.ZodEnum<{
+            diverged: "diverged";
+            unmapped: "unmapped";
+            archived_ahead: "archived_ahead";
+            shallow_local_work: "shallow_local_work";
+            upstream_not_a_branch: "upstream_not_a_branch";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"local_only">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"cleanup">;
+        reason: z.ZodEnum<{
+            merged: "merged";
+            upstream_gone: "upstream_gone";
+        }>;
+        removable_worktree: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type ReposBranchStatus = z.infer<typeof ReposBranchStatus>;
+/** Whether an entry's primary checkout sits where the registry puts it. */
+export declare const ReposAtRest: z.ZodObject<{
+    on_branch: z.ZodNullable<z.ZodBoolean>;
+    clean: z.ZodBoolean;
+    idle: z.ZodBoolean;
+    followed: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"in_sync">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"ahead">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"behind">;
+        commits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"diverged">;
+        ahead: z.ZodNumber;
+        behind: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"shallow">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"gone">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unmapped">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"untracked">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type ReposAtRest = z.infer<typeof ReposAtRest>;
+/** Why a worktree wasn't probed. */
+export declare const ReposUnprobedWhy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"prunable">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    error: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ReposUnprobedWhy = z.infer<typeof ReposUnprobedWhy>;
+/** What an unprobed worktree's git dir holds that a prune would lose. */
+export declare const ReposGitDirHolds: z.ZodObject<{
+    submodules: z.ZodBoolean;
+    worktree_refs: z.ZodBoolean;
+    staged: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ReposGitDirHolds = z.infer<typeof ReposGitDirHolds>;
+/** What pruning an unprobed worktree would lose. */
+export declare const ReposPruneLoss: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"operation">;
+    op: z.ZodEnum<{
+        rebase: "rebase";
+        merge: "merge";
+        cherry_pick: "cherry_pick";
+        revert: "revert";
+        bisect: "bisect";
+        sequencer: "sequencer";
+        am: "am";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"detached_head">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown_head">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing_branch">;
+    name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"submodules">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree_refs">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"staged_changes">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unmatched_git_dir">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"relative_gitdir">;
+    git_dir: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ReposPruneLoss = z.infer<typeof ReposPruneLoss>;
+/** Whether pruning an unprobed worktree is safe. */
+export declare const ReposPrune: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"safe">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"loses">;
+    losses: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"operation">;
+        op: z.ZodEnum<{
+            rebase: "rebase";
+            merge: "merge";
+            cherry_pick: "cherry_pick";
+            revert: "revert";
+            bisect: "bisect";
+            sequencer: "sequencer";
+            am: "am";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"detached_head">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown_head">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"missing_branch">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"submodules">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"worktree_refs">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"staged_changes">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unmatched_git_dir">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"relative_gitdir">;
+        git_dir: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"moved">;
+    to: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type ReposPrune = z.infer<typeof ReposPrune>;
+/** A worktree of the repo that couldn't be probed. */
+export declare const ReposUnprobedWorktree: z.ZodObject<{
+    path: z.ZodString;
+    git_dir: z.ZodNullable<z.ZodString>;
+    head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"branch">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"detached">;
+        commit: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    locked: z.ZodBoolean;
+    in_progress: z.ZodNullable<z.ZodEnum<{
+        rebase: "rebase";
+        merge: "merge";
+        cherry_pick: "cherry_pick";
+        revert: "revert";
+        bisect: "bisect";
+        sequencer: "sequencer";
+        am: "am";
+    }>>;
+    why: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"prunable">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        error: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    holds: z.ZodNullable<z.ZodObject<{
+        submodules: z.ZodBoolean;
+        worktree_refs: z.ZodBoolean;
+        staged: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReposUnprobedWorktree = z.infer<typeof ReposUnprobedWorktree>;
+/** An unprobed worktree (flattened) with its prune verdict and live sessions. */
+export declare const ReposUnprobedWorktreeStatus: z.ZodObject<{
+    path: z.ZodString;
+    git_dir: z.ZodNullable<z.ZodString>;
+    head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"branch">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"detached">;
+        commit: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    locked: z.ZodBoolean;
+    in_progress: z.ZodNullable<z.ZodEnum<{
+        rebase: "rebase";
+        merge: "merge";
+        cherry_pick: "cherry_pick";
+        revert: "revert";
+        bisect: "bisect";
+        sequencer: "sequencer";
+        am: "am";
+    }>>;
+    why: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"prunable">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        error: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    holds: z.ZodNullable<z.ZodObject<{
+        submodules: z.ZodBoolean;
+        worktree_refs: z.ZodBoolean;
+        staged: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    prune: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"safe">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"loses">;
+        losses: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"operation">;
+            op: z.ZodEnum<{
+                rebase: "rebase";
+                merge: "merge";
+                cherry_pick: "cherry_pick";
+                revert: "revert";
+                bisect: "bisect";
+                sequencer: "sequencer";
+                am: "am";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"detached_head">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown_head">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing_branch">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"submodules">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"worktree_refs">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"staged_changes">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unmatched_git_dir">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"relative_gitdir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"moved">;
+        to: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+    busy: z.ZodArray<z.ZodObject<{
+        pid: z.ZodNumber;
+        cwd: z.ZodString;
+        worktree: z.ZodNullable<z.ZodString>;
+        process_cwd: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            session_file: "session_file";
+            roster_worker: "roster_worker";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReposUnprobedWorktreeStatus = z.infer<typeof ReposUnprobedWorktreeStatus>;
+/** The `origin` remote as git sees it, when it isn't the registry's `url`. */
+export declare const ReposOriginRemote: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"no_url">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strict>], "kind">;
+export type ReposOriginRemote = z.infer<typeof ReposOriginRemote>;
+/** Why no `git remote` command fits an origin's fix. */
+export declare const ReposOriginByHand: z.ZodEnum<{
+    outside_repo_file: "outside_repo_file";
+    valueless_url: "valueless_url";
+    empty_value: "empty_value";
+    several_urls: "several_urls";
+}>;
+export type ReposOriginByHand = z.infer<typeof ReposOriginByHand>;
+/** How to point `origin` at the registry's URL. */
+export declare const ReposOriginFix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"add">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"set_url">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"by_hand">;
+    reason: z.ZodEnum<{
+        outside_repo_file: "outside_repo_file";
+        valueless_url: "valueless_url";
+        empty_value: "empty_value";
+        several_urls: "several_urls";
+    }>;
+}, z.core.$strict>], "kind">;
+export type ReposOriginFix = z.infer<typeof ReposOriginFix>;
+/** Why a remote couldn't be reached. */
+export declare const ReposUnreachableCause: z.ZodEnum<{
+    dns: "dns";
+    connection: "connection";
+    host_key: "host_key";
+    auth: "auth";
+}>;
+export type ReposUnreachableCause = z.infer<typeof ReposUnreachableCause>;
+/** How to repair a fetch refspec naming a ref gone from origin. */
+export declare const ReposRefGoneFix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"unset_refspec">;
+    pattern: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"set_branches">;
+    branch: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"by_hand">;
+}, z.core.$strict>], "kind">;
+export type ReposRefGoneFix = z.infer<typeof ReposRefGoneFix>;
+/**
+ * Why a fetch or the visibility check failed, or why the tool refused to
+ * fetch: Rust's `RemoteFailure` without `rejected`, which only a push meets.
+ */
+export declare const ReposFetchFailure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"ref_gone">;
+    refname: z.ZodString;
+    fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"unset_refspec">;
+        pattern: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"set_branches">;
+        branch: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"by_hand">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unreachable">;
+    cause: z.ZodEnum<{
+        dns: "dns";
+        connection: "connection";
+        host_key: "host_key";
+        auth: "auth";
+    }>;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"repo_not_found">;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"timed_out">;
+    after_secs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"refspec_outside_origin">;
+    refspec: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"origin_refs_shared">;
+    remote: z.ZodString;
+    refspec: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+    path: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ReposFetchFailure = z.infer<typeof ReposFetchFailure>;
+/** What an anonymous read of a repo declared private found. */
+export declare const ReposVisibilityCheck: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"leak">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"private">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+    failure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ref_gone">;
+        refname: z.ZodString;
+        fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"unset_refspec">;
+            pattern: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set_branches">;
+            branch: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"by_hand">;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unreachable">;
+        cause: z.ZodEnum<{
+            dns: "dns";
+            connection: "connection";
+            host_key: "host_key";
+            auth: "auth";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"repo_not_found">;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"timed_out">;
+        after_secs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"refspec_outside_origin">;
+        refspec: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"origin_refs_shared">;
+        remote: z.ZodString;
+        refspec: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+        path: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">;
+export type ReposVisibilityCheck = z.infer<typeof ReposVisibilityCheck>;
+/** What kind of failure stopped an entry's probe. */
+export declare const ReposProbeErrorKind: z.ZodEnum<{
+    path_unreadable: "path_unreadable";
+    non_utf8_path: "non_utf8_path";
+    config_unreadable: "config_unreadable";
+    fetch_url_unreadable: "fetch_url_unreadable";
+    push_urls_unreadable: "push_urls_unreadable";
+    git_not_run: "git_not_run";
+    git_timed_out: "git_timed_out";
+    git_failed: "git_failed";
+    unexpected_output: "unexpected_output";
+}>;
+export type ReposProbeErrorKind = z.infer<typeof ReposProbeErrorKind>;
+/** Why an entry's probe failed: its kind, and a message for display. */
+export declare const ReposProbeError: z.ZodObject<{
+    kind: z.ZodEnum<{
+        path_unreadable: "path_unreadable";
+        non_utf8_path: "non_utf8_path";
+        config_unreadable: "config_unreadable";
+        fetch_url_unreadable: "fetch_url_unreadable";
+        push_urls_unreadable: "push_urls_unreadable";
+        git_not_run: "git_not_run";
+        git_timed_out: "git_timed_out";
+        git_failed: "git_failed";
+        unexpected_output: "unexpected_output";
+    }>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type ReposProbeError = z.infer<typeof ReposProbeError>;
+/** Why sync would stop on an entry and leave it to a person. */
+export declare const ReposNeedsHuman: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"not_a_repo">;
+    detail: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"operation_in_progress">;
+    checkout: z.ZodString;
+    op: z.ZodEnum<{
+        rebase: "rebase";
+        merge: "merge";
+        cherry_pick: "cherry_pick";
+        revert: "revert";
+        bisect: "bisect";
+        sequencer: "sequencer";
+        am: "am";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"origin_mismatch">;
+    origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"url">;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"no_url">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "kind">;
+    expected: z.ZodString;
+    fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"add">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"set_url">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"by_hand">;
+        reason: z.ZodEnum<{
+            outside_repo_file: "outside_repo_file";
+            valueless_url: "valueless_url";
+            empty_value: "empty_value";
+            several_urls: "several_urls";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"origin_not_https">;
+    fetch_url: z.ZodString;
+    expected: z.ZodString;
+    fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"add">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"set_url">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"by_hand">;
+        reason: z.ZodEnum<{
+            outside_repo_file: "outside_repo_file";
+            valueless_url: "valueless_url";
+            empty_value: "empty_value";
+            several_urls: "several_urls";
+        }>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fetch_url_mismatch">;
+    fetch_url: z.ZodString;
+    expected: z.ZodString;
+    fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"add">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"set_url">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"by_hand">;
+        reason: z.ZodEnum<{
+            outside_repo_file: "outside_repo_file";
+            valueless_url: "valueless_url";
+            empty_value: "empty_value";
+            several_urls: "several_urls";
+        }>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree_unreadable">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"default_branch_missing">;
+    branch: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"default_branch_no_upstream">;
+    branch: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"default_branch_gone">;
+    branch: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unexpected_detached">;
+    checkout: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"checkout_unresolvable">;
+    checkout: z.ZodString;
+    path: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unlisted_git_dir">;
+    git_dir: z.ZodString;
+    head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"branch">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"detached">;
+        commit: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    busy: z.ZodArray<z.ZodObject<{
+        pid: z.ZodNumber;
+        cwd: z.ZodString;
+        worktree: z.ZodNullable<z.ZodString>;
+        process_cwd: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            session_file: "session_file";
+            roster_worker: "roster_worker";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"push_url_mismatch">;
+    push_urls: z.ZodArray<z.ZodString>;
+    expected: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"clone_shares_repo">;
+    with: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"cloned_unregistered">;
+    dir: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ReposNeedsHuman = z.infer<typeof ReposNeedsHuman>;
+/** One registry entry's state. */
+export declare const ReposEntryStatus: z.ZodObject<{
+    key: z.ZodString;
+    kind: z.ZodEnum<{
+        repo: "repo";
+        reference: "reference";
+    }>;
+    dir: z.ZodString;
+    url: z.ZodString;
+    writable: z.ZodBoolean;
+    archived: z.ZodBoolean;
+    visibility: z.ZodNullable<z.ZodEnum<{
+        private: "private";
+        public: "public";
+    }>>;
+    ci: z.ZodBoolean;
+    branch: z.ZodNullable<z.ZodString>;
+    pinned: z.ZodBoolean;
+    refresh: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"act">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"held">;
+        by: z.ZodEnum<{
+            entry: "entry";
+            pinned: "pinned";
+            origin_not_https: "origin_not_https";
+        }>;
+    }, z.core.$strict>], "kind">>;
+    presence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"present">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"not_a_repo">;
+    }, z.core.$strict>], "kind">;
+    clone: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"act">;
+        recipe: z.ZodObject<{
+            url: z.ZodString;
+            branch: z.ZodNullable<z.ZodString>;
+            shallow: z.ZodBoolean;
+            sparse: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"held">;
+        recipe: z.ZodObject<{
+            url: z.ZodString;
+            branch: z.ZodNullable<z.ZodString>;
+            shallow: z.ZodBoolean;
+            sparse: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        by: z.ZodEnum<{
+            entry: "entry";
+            unprobed_worktree: "unprobed_worktree";
+            busy: "busy";
+        }>;
+    }, z.core.$strict>], "kind">>;
+    layout: z.ZodNullable<z.ZodObject<{
+        shallow: z.ZodBoolean;
+        sparse: z.ZodBoolean;
+        partial_filter: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    checkouts: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        primary: z.ZodBoolean;
+        head: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"branch">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"detached">;
+            commit: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        uncommitted: z.ZodObject<{
+            staged: z.ZodNumber;
+            unstaged: z.ZodNumber;
+            untracked: z.ZodNumber;
+            conflicted: z.ZodNumber;
+        }, z.core.$strict>;
+        in_progress: z.ZodNullable<z.ZodEnum<{
+            rebase: "rebase";
+            merge: "merge";
+            cherry_pick: "cherry_pick";
+            revert: "revert";
+            bisect: "bisect";
+            sequencer: "sequencer";
+            am: "am";
+        }>>;
+        locked: z.ZodBoolean;
+        linked: z.ZodBoolean;
+        submodules: z.ZodNullable<z.ZodBoolean>;
+        busy: z.ZodArray<z.ZodObject<{
+            pid: z.ZodNumber;
+            cwd: z.ZodString;
+            worktree: z.ZodNullable<z.ZodString>;
+            process_cwd: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                session_file: "session_file";
+                roster_worker: "roster_worker";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    branches: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        upstream: z.ZodNullable<z.ZodString>;
+        worktree: z.ZodNullable<z.ZodString>;
+        symref: z.ZodNullable<z.ZodString>;
+        unique_commits: z.ZodNumber;
+        newest_commit_at: z.ZodNumber;
+        relation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"in_sync">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"ahead">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"behind">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"diverged">;
+            ahead: z.ZodNumber;
+            behind: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"shallow">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"gone">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unmapped">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"untracked">;
+        }, z.core.$strict>], "kind">;
+        verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"quiet">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"act">;
+            action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"push">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fast_forward">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"move">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"held">;
+            action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"push">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fast_forward">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"move">;
+            }, z.core.$strict>], "kind">;
+            by: z.ZodEnum<{
+                entry: "entry";
+                pinned: "pinned";
+                push_url: "push_url";
+                fetch_failed: "fetch_failed";
+                dirty_checkout: "dirty_checkout";
+                unprobed_worktree: "unprobed_worktree";
+                several_checkouts: "several_checkouts";
+                busy: "busy";
+                busy_unknown: "busy_unknown";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"needs_human">;
+            reason: z.ZodEnum<{
+                diverged: "diverged";
+                unmapped: "unmapped";
+                archived_ahead: "archived_ahead";
+                shallow_local_work: "shallow_local_work";
+                upstream_not_a_branch: "upstream_not_a_branch";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"local_only">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"cleanup">;
+            reason: z.ZodEnum<{
+                merged: "merged";
+                upstream_gone: "upstream_gone";
+            }>;
+            removable_worktree: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+    at_rest: z.ZodNullable<z.ZodObject<{
+        on_branch: z.ZodNullable<z.ZodBoolean>;
+        clean: z.ZodBoolean;
+        idle: z.ZodBoolean;
+        followed: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"in_sync">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"ahead">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"behind">;
+            commits: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"diverged">;
+            ahead: z.ZodNumber;
+            behind: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"shallow">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"gone">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unmapped">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"untracked">;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    stashes: z.ZodNumber;
+    fetched_at: z.ZodNullable<z.ZodNumber>;
+    needs_human: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"not_a_repo">;
+        detail: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"operation_in_progress">;
+        checkout: z.ZodString;
+        op: z.ZodEnum<{
+            rebase: "rebase";
+            merge: "merge";
+            cherry_pick: "cherry_pick";
+            revert: "revert";
+            bisect: "bisect";
+            sequencer: "sequencer";
+            am: "am";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"origin_mismatch">;
+        origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"url">;
+            url: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"no_url">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+        }, z.core.$strict>], "kind">;
+        expected: z.ZodString;
+        fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"add">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set_url">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"by_hand">;
+            reason: z.ZodEnum<{
+                outside_repo_file: "outside_repo_file";
+                valueless_url: "valueless_url";
+                empty_value: "empty_value";
+                several_urls: "several_urls";
+            }>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"origin_not_https">;
+        fetch_url: z.ZodString;
+        expected: z.ZodString;
+        fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"add">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set_url">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"by_hand">;
+            reason: z.ZodEnum<{
+                outside_repo_file: "outside_repo_file";
+                valueless_url: "valueless_url";
+                empty_value: "empty_value";
+                several_urls: "several_urls";
+            }>;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fetch_url_mismatch">;
+        fetch_url: z.ZodString;
+        expected: z.ZodString;
+        fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"add">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set_url">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"by_hand">;
+            reason: z.ZodEnum<{
+                outside_repo_file: "outside_repo_file";
+                valueless_url: "valueless_url";
+                empty_value: "empty_value";
+                several_urls: "several_urls";
+            }>;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"worktree_unreadable">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"default_branch_missing">;
+        branch: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"default_branch_no_upstream">;
+        branch: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"default_branch_gone">;
+        branch: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unexpected_detached">;
+        checkout: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"checkout_unresolvable">;
+        checkout: z.ZodString;
+        path: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unlisted_git_dir">;
+        git_dir: z.ZodString;
+        head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"branch">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"detached">;
+            commit: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        busy: z.ZodArray<z.ZodObject<{
+            pid: z.ZodNumber;
+            cwd: z.ZodString;
+            worktree: z.ZodNullable<z.ZodString>;
+            process_cwd: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                session_file: "session_file";
+                roster_worker: "roster_worker";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"push_url_mismatch">;
+        push_urls: z.ZodArray<z.ZodString>;
+        expected: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"clone_shares_repo">;
+        with: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"cloned_unregistered">;
+        dir: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    probe_error: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            path_unreadable: "path_unreadable";
+            non_utf8_path: "non_utf8_path";
+            config_unreadable: "config_unreadable";
+            fetch_url_unreadable: "fetch_url_unreadable";
+            push_urls_unreadable: "push_urls_unreadable";
+            git_not_run: "git_not_run";
+            git_timed_out: "git_timed_out";
+            git_failed: "git_failed";
+            unexpected_output: "unexpected_output";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    unprobed_worktrees: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        git_dir: z.ZodNullable<z.ZodString>;
+        head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"branch">;
+            name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"detached">;
+            commit: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        locked: z.ZodBoolean;
+        in_progress: z.ZodNullable<z.ZodEnum<{
+            rebase: "rebase";
+            merge: "merge";
+            cherry_pick: "cherry_pick";
+            revert: "revert";
+            bisect: "bisect";
+            sequencer: "sequencer";
+            am: "am";
+        }>>;
+        why: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"prunable">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            error: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        holds: z.ZodNullable<z.ZodObject<{
+            submodules: z.ZodBoolean;
+            worktree_refs: z.ZodBoolean;
+            staged: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        prune: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"safe">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"loses">;
+            losses: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"operation">;
+                op: z.ZodEnum<{
+                    rebase: "rebase";
+                    merge: "merge";
+                    cherry_pick: "cherry_pick";
+                    revert: "revert";
+                    bisect: "bisect";
+                    sequencer: "sequencer";
+                    am: "am";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"detached_head">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unknown_head">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing_branch">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"submodules">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"worktree_refs">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"staged_changes">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unmatched_git_dir">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"relative_gitdir">;
+                git_dir: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"moved">;
+            to: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "kind">>;
+        busy: z.ZodArray<z.ZodObject<{
+            pid: z.ZodNumber;
+            cwd: z.ZodString;
+            worktree: z.ZodNullable<z.ZodString>;
+            process_cwd: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                session_file: "session_file";
+                roster_worker: "roster_worker";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    fetch_error: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ref_gone">;
+        refname: z.ZodString;
+        fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"unset_refspec">;
+            pattern: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set_branches">;
+            branch: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"by_hand">;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unreachable">;
+        cause: z.ZodEnum<{
+            dns: "dns";
+            connection: "connection";
+            host_key: "host_key";
+            auth: "auth";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"repo_not_found">;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"timed_out">;
+        after_secs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"refspec_outside_origin">;
+        refspec: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"origin_refs_shared">;
+        remote: z.ZodString;
+        refspec: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+        path: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    visibility_check: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"leak">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"private">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        failure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"ref_gone">;
+            refname: z.ZodString;
+            fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unset_refspec">;
+                pattern: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_branches">;
+                branch: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unreachable">;
+            cause: z.ZodEnum<{
+                dns: "dns";
+                connection: "connection";
+                host_key: "host_key";
+                auth: "auth";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"repo_not_found">;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"timed_out">;
+            after_secs: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"refspec_outside_origin">;
+            refspec: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_refs_shared">;
+            remote: z.ZodString;
+            refspec: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+            path: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type ReposEntryStatus = z.infer<typeof ReposEntryStatus>;
+/** What keeps a moved worktree's repair from being offered. */
+export declare const ReposRepairBlock: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"rewrites">;
+    path: z.ZodString;
+    git_dir: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"claimed_dir">;
+    git_dir: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"swapped">;
+    git_dir: z.ZodString;
+    with: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"relative_gitdir">;
+    git_dir: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unreadable_gitdir">;
+    git_dir: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"non_utf8_path">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"nul_in_gitdir">;
+    git_dir: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type ReposRepairBlock = z.infer<typeof ReposRepairBlock>;
+/**
+ * A child of the workspace root holding a `.git` that no registry entry
+ * claims, its `kind` flattened beside its own fields.
+ */
+export declare const ReposUnregisteredClone: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"clone">;
+    dir: z.ZodString;
+    origin: z.ZodNullable<z.ZodString>;
+    owned: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree">;
+    dir: z.ZodString;
+    origin: z.ZodNullable<z.ZodString>;
+    owned: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"moved_worktree">;
+    entry: z.ZodString;
+    blocked_by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"rewrites">;
+        path: z.ZodString;
+        git_dir: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"claimed_dir">;
+        git_dir: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"swapped">;
+        git_dir: z.ZodString;
+        with: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"relative_gitdir">;
+        git_dir: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unreadable_gitdir">;
+        git_dir: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"non_utf8_path">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"nul_in_gitdir">;
+        git_dir: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    exit_noise: z.ZodNullable<z.ZodString>;
+    dir: z.ZodString;
+    origin: z.ZodNullable<z.ZodString>;
+    owned: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"orphaned_worktree">;
+    entry: z.ZodString;
+    dir: z.ZodString;
+    origin: z.ZodNullable<z.ZodString>;
+    owned: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"shared_git_dir">;
+    entry: z.ZodString;
+    with: z.ZodNullable<z.ZodString>;
+    dir: z.ZodString;
+    origin: z.ZodNullable<z.ZodString>;
+    owned: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unfinished_clone">;
+    dir: z.ZodString;
+    origin: z.ZodNullable<z.ZodString>;
+    owned: z.ZodBoolean;
+}, z.core.$strict>], "kind">;
+export type ReposUnregisteredClone = z.infer<typeof ReposUnregisteredClone>;
+/** The `repos status --json` report. */
+export declare const ReposStatusReport: z.ZodObject<{
+    version: z.ZodLiteral<18>;
+    workspace: z.ZodString;
+    registry: z.ZodString;
+    fetched: z.ZodBoolean;
+    sessions: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"available">;
+        unscoped: z.ZodArray<z.ZodObject<{
+            pid: z.ZodNumber;
+            cwd: z.ZodString;
+            worktree: z.ZodNullable<z.ZodString>;
+            process_cwd: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                session_file: "session_file";
+                roster_worker: "roster_worker";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unavailable">;
+        reason: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"home_unknown">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"relative_config_dir">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unreadable">;
+            path: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unparseable">;
+            path: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"foreign_pid_domain">;
+            path: z.ZodString;
+            pid_domain: z.ZodString;
+            source: z.ZodEnum<{
+                session_file: "session_file";
+                roster_worker: "roster_worker";
+            }>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>], "kind">;
+    entries: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodEnum<{
+            repo: "repo";
+            reference: "reference";
+        }>;
+        dir: z.ZodString;
+        url: z.ZodString;
+        writable: z.ZodBoolean;
+        archived: z.ZodBoolean;
+        visibility: z.ZodNullable<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        ci: z.ZodBoolean;
+        branch: z.ZodNullable<z.ZodString>;
+        pinned: z.ZodBoolean;
+        refresh: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"act">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"held">;
+            by: z.ZodEnum<{
+                entry: "entry";
+                pinned: "pinned";
+                origin_not_https: "origin_not_https";
+            }>;
+        }, z.core.$strict>], "kind">>;
+        presence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"present">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"not_a_repo">;
+        }, z.core.$strict>], "kind">;
+        clone: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"act">;
+            recipe: z.ZodObject<{
+                url: z.ZodString;
+                branch: z.ZodNullable<z.ZodString>;
+                shallow: z.ZodBoolean;
+                sparse: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"held">;
+            recipe: z.ZodObject<{
+                url: z.ZodString;
+                branch: z.ZodNullable<z.ZodString>;
+                shallow: z.ZodBoolean;
+                sparse: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            by: z.ZodEnum<{
+                entry: "entry";
+                unprobed_worktree: "unprobed_worktree";
+                busy: "busy";
+            }>;
+        }, z.core.$strict>], "kind">>;
+        layout: z.ZodNullable<z.ZodObject<{
+            shallow: z.ZodBoolean;
+            sparse: z.ZodBoolean;
+            partial_filter: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        checkouts: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            primary: z.ZodBoolean;
+            head: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"branch">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"detached">;
+                commit: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            uncommitted: z.ZodObject<{
+                staged: z.ZodNumber;
+                unstaged: z.ZodNumber;
+                untracked: z.ZodNumber;
+                conflicted: z.ZodNumber;
+            }, z.core.$strict>;
+            in_progress: z.ZodNullable<z.ZodEnum<{
+                rebase: "rebase";
+                merge: "merge";
+                cherry_pick: "cherry_pick";
+                revert: "revert";
+                bisect: "bisect";
+                sequencer: "sequencer";
+                am: "am";
+            }>>;
+            locked: z.ZodBoolean;
+            linked: z.ZodBoolean;
+            submodules: z.ZodNullable<z.ZodBoolean>;
+            busy: z.ZodArray<z.ZodObject<{
+                pid: z.ZodNumber;
+                cwd: z.ZodString;
+                worktree: z.ZodNullable<z.ZodString>;
+                process_cwd: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    session_file: "session_file";
+                    roster_worker: "roster_worker";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        branches: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            upstream: z.ZodNullable<z.ZodString>;
+            worktree: z.ZodNullable<z.ZodString>;
+            symref: z.ZodNullable<z.ZodString>;
+            unique_commits: z.ZodNumber;
+            newest_commit_at: z.ZodNumber;
+            relation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"in_sync">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ahead">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"behind">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"diverged">;
+                ahead: z.ZodNumber;
+                behind: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"shallow">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"gone">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unmapped">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"untracked">;
+            }, z.core.$strict>], "kind">;
+            verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"quiet">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"act">;
+                action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"push">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fast_forward">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"move">;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"held">;
+                action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"push">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fast_forward">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"move">;
+                }, z.core.$strict>], "kind">;
+                by: z.ZodEnum<{
+                    entry: "entry";
+                    pinned: "pinned";
+                    push_url: "push_url";
+                    fetch_failed: "fetch_failed";
+                    dirty_checkout: "dirty_checkout";
+                    unprobed_worktree: "unprobed_worktree";
+                    several_checkouts: "several_checkouts";
+                    busy: "busy";
+                    busy_unknown: "busy_unknown";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"needs_human">;
+                reason: z.ZodEnum<{
+                    diverged: "diverged";
+                    unmapped: "unmapped";
+                    archived_ahead: "archived_ahead";
+                    shallow_local_work: "shallow_local_work";
+                    upstream_not_a_branch: "upstream_not_a_branch";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"local_only">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"cleanup">;
+                reason: z.ZodEnum<{
+                    merged: "merged";
+                    upstream_gone: "upstream_gone";
+                }>;
+                removable_worktree: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+        at_rest: z.ZodNullable<z.ZodObject<{
+            on_branch: z.ZodNullable<z.ZodBoolean>;
+            clean: z.ZodBoolean;
+            idle: z.ZodBoolean;
+            followed: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"in_sync">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ahead">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"behind">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"diverged">;
+                ahead: z.ZodNumber;
+                behind: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"shallow">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"gone">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unmapped">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"untracked">;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+        stashes: z.ZodNumber;
+        fetched_at: z.ZodNullable<z.ZodNumber>;
+        needs_human: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"not_a_repo">;
+            detail: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"operation_in_progress">;
+            checkout: z.ZodString;
+            op: z.ZodEnum<{
+                rebase: "rebase";
+                merge: "merge";
+                cherry_pick: "cherry_pick";
+                revert: "revert";
+                bisect: "bisect";
+                sequencer: "sequencer";
+                am: "am";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_mismatch">;
+            origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"url">;
+                url: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"no_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing">;
+            }, z.core.$strict>], "kind">;
+            expected: z.ZodString;
+            fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"add">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+                reason: z.ZodEnum<{
+                    outside_repo_file: "outside_repo_file";
+                    valueless_url: "valueless_url";
+                    empty_value: "empty_value";
+                    several_urls: "several_urls";
+                }>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_not_https">;
+            fetch_url: z.ZodString;
+            expected: z.ZodString;
+            fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"add">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+                reason: z.ZodEnum<{
+                    outside_repo_file: "outside_repo_file";
+                    valueless_url: "valueless_url";
+                    empty_value: "empty_value";
+                    several_urls: "several_urls";
+                }>;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fetch_url_mismatch">;
+            fetch_url: z.ZodString;
+            expected: z.ZodString;
+            fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"add">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+                reason: z.ZodEnum<{
+                    outside_repo_file: "outside_repo_file";
+                    valueless_url: "valueless_url";
+                    empty_value: "empty_value";
+                    several_urls: "several_urls";
+                }>;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"worktree_unreadable">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"default_branch_missing">;
+            branch: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"default_branch_no_upstream">;
+            branch: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"default_branch_gone">;
+            branch: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unexpected_detached">;
+            checkout: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"checkout_unresolvable">;
+            checkout: z.ZodString;
+            path: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unlisted_git_dir">;
+            git_dir: z.ZodString;
+            head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"branch">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"detached">;
+                commit: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            busy: z.ZodArray<z.ZodObject<{
+                pid: z.ZodNumber;
+                cwd: z.ZodString;
+                worktree: z.ZodNullable<z.ZodString>;
+                process_cwd: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    session_file: "session_file";
+                    roster_worker: "roster_worker";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"push_url_mismatch">;
+            push_urls: z.ZodArray<z.ZodString>;
+            expected: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"clone_shares_repo">;
+            with: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"cloned_unregistered">;
+            dir: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        probe_error: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                path_unreadable: "path_unreadable";
+                non_utf8_path: "non_utf8_path";
+                config_unreadable: "config_unreadable";
+                fetch_url_unreadable: "fetch_url_unreadable";
+                push_urls_unreadable: "push_urls_unreadable";
+                git_not_run: "git_not_run";
+                git_timed_out: "git_timed_out";
+                git_failed: "git_failed";
+                unexpected_output: "unexpected_output";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        unprobed_worktrees: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            git_dir: z.ZodNullable<z.ZodString>;
+            head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"branch">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"detached">;
+                commit: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            locked: z.ZodBoolean;
+            in_progress: z.ZodNullable<z.ZodEnum<{
+                rebase: "rebase";
+                merge: "merge";
+                cherry_pick: "cherry_pick";
+                revert: "revert";
+                bisect: "bisect";
+                sequencer: "sequencer";
+                am: "am";
+            }>>;
+            why: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"prunable">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"failed">;
+                error: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            holds: z.ZodNullable<z.ZodObject<{
+                submodules: z.ZodBoolean;
+                worktree_refs: z.ZodBoolean;
+                staged: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            prune: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"safe">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"loses">;
+                losses: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"operation">;
+                    op: z.ZodEnum<{
+                        rebase: "rebase";
+                        merge: "merge";
+                        cherry_pick: "cherry_pick";
+                        revert: "revert";
+                        bisect: "bisect";
+                        sequencer: "sequencer";
+                        am: "am";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"detached_head">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"unknown_head">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"missing_branch">;
+                    name: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"submodules">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"worktree_refs">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"staged_changes">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"unmatched_git_dir">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"relative_gitdir">;
+                    git_dir: z.ZodString;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"moved">;
+                to: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>], "kind">>;
+            busy: z.ZodArray<z.ZodObject<{
+                pid: z.ZodNumber;
+                cwd: z.ZodString;
+                worktree: z.ZodNullable<z.ZodString>;
+                process_cwd: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    session_file: "session_file";
+                    roster_worker: "roster_worker";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        fetch_error: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"ref_gone">;
+            refname: z.ZodString;
+            fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unset_refspec">;
+                pattern: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_branches">;
+                branch: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unreachable">;
+            cause: z.ZodEnum<{
+                dns: "dns";
+                connection: "connection";
+                host_key: "host_key";
+                auth: "auth";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"repo_not_found">;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"timed_out">;
+            after_secs: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"refspec_outside_origin">;
+            refspec: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_refs_shared">;
+            remote: z.ZodString;
+            refspec: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+            path: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        visibility_check: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"leak">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"private">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+            failure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"ref_gone">;
+                refname: z.ZodString;
+                fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"unset_refspec">;
+                    pattern: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"set_branches">;
+                    branch: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"by_hand">;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unreachable">;
+                cause: z.ZodEnum<{
+                    dns: "dns";
+                    connection: "connection";
+                    host_key: "host_key";
+                    auth: "auth";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"repo_not_found">;
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"timed_out">;
+                after_secs: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"failed">;
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"refspec_outside_origin">;
+                refspec: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"origin_refs_shared">;
+                remote: z.ZodString;
+                refspec: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+                path: z.ZodString;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    unregistered: z.ZodNullable<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"clone">;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"worktree">;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"moved_worktree">;
+        entry: z.ZodString;
+        blocked_by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"rewrites">;
+            path: z.ZodString;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"claimed_dir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"swapped">;
+            git_dir: z.ZodString;
+            with: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"relative_gitdir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unreadable_gitdir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"non_utf8_path">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"nul_in_gitdir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        exit_noise: z.ZodNullable<z.ZodString>;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"orphaned_worktree">;
+        entry: z.ZodString;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"shared_git_dir">;
+        entry: z.ZodString;
+        with: z.ZodNullable<z.ZodString>;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unfinished_clone">;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>;
+export type ReposStatusReport = z.infer<typeof ReposStatusReport>;
+/**
+ * A fatal error as `repos status --json` prints it, its `kind` flattened
+ * beside `message` and `hint`. Only the kinds `status` can print: the rest
+ * of Rust's `ErrorKind` are `repos push`'s, or precede knowing `--json`.
+ */
+export declare const ReposStatusErrorBody: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"references_with_targets">;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"root_not_found">;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"registry_not_found">;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"root_in_entry">;
+    key: z.ZodString;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"registry_read">;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"registry_parse">;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"registry_invalid">;
+    issues: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"repo_not_owned">;
+        key: z.ZodString;
+        account: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fork_not_owned">;
+        key: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"dir_not_a_name">;
+        entry: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repo: "repo";
+                reference: "reference";
+            }>;
+            key: z.ZodString;
+        }, z.core.$strict>;
+        dir: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"dir_claimed_twice">;
+        dir: z.ZodString;
+        first: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repo: "repo";
+                reference: "reference";
+            }>;
+            key: z.ZodString;
+        }, z.core.$strict>;
+        second: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repo: "repo";
+                reference: "reference";
+            }>;
+            key: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"key_in_both">;
+        key: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"key_is_other_dir">;
+        key: z.ZodString;
+        entry: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repo: "repo";
+                reference: "reference";
+            }>;
+            key: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown_checkout_ref">;
+        key: z.ZodString;
+        field: z.ZodEnum<{
+            requires: "requires";
+            consults: "consults";
+        }>;
+        target: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"self_ref">;
+        key: z.ZodString;
+        field: z.ZodEnum<{
+            requires: "requires";
+            consults: "consults";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"requires_and_consults">;
+        key: z.ZodString;
+        target: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"git_not_found">;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"git_too_old">;
+    found: z.ZodString;
+    required: z.ZodString;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown_entry">;
+    name: z.ZodString;
+    suggestions: z.ZodArray<z.ZodString>;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"io">;
+    message: z.ZodString;
+    hint: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type ReposStatusErrorBody = z.infer<typeof ReposStatusErrorBody>;
+/** The document `repos status --json` prints on a fatal error, in place of the report. */
+export declare const ReposStatusErrorReport: z.ZodObject<{
+    version: z.ZodLiteral<18>;
+    error: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"references_with_targets">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"root_not_found">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_not_found">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"root_in_entry">;
+        key: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_read">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_parse">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_invalid">;
+        issues: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"repo_not_owned">;
+            key: z.ZodString;
+            account: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fork_not_owned">;
+            key: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"dir_not_a_name">;
+            entry: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+            dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"dir_claimed_twice">;
+            dir: z.ZodString;
+            first: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+            second: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"key_in_both">;
+            key: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"key_is_other_dir">;
+            key: z.ZodString;
+            entry: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown_checkout_ref">;
+            key: z.ZodString;
+            field: z.ZodEnum<{
+                requires: "requires";
+                consults: "consults";
+            }>;
+            target: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self_ref">;
+            key: z.ZodString;
+            field: z.ZodEnum<{
+                requires: "requires";
+                consults: "consults";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"requires_and_consults">;
+            key: z.ZodString;
+            target: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"git_not_found">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"git_too_old">;
+        found: z.ZodString;
+        required: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown_entry">;
+        name: z.ZodString;
+        suggestions: z.ZodArray<z.ZodString>;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"io">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type ReposStatusErrorReport = z.infer<typeof ReposStatusErrorReport>;
+/**
+ * Either document `repos status --json` prints. No tag is needed: `error`
+ * is the error document's alone, and each side's strictness refuses the
+ * other's fields. A consumer wanting a sharper parse error branches on
+ * `error` first and parses with that side's schema.
+ */
+export declare const ReposStatusDocument: z.ZodUnion<readonly [z.ZodObject<{
+    version: z.ZodLiteral<18>;
+    workspace: z.ZodString;
+    registry: z.ZodString;
+    fetched: z.ZodBoolean;
+    sessions: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"available">;
+        unscoped: z.ZodArray<z.ZodObject<{
+            pid: z.ZodNumber;
+            cwd: z.ZodString;
+            worktree: z.ZodNullable<z.ZodString>;
+            process_cwd: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                session_file: "session_file";
+                roster_worker: "roster_worker";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unavailable">;
+        reason: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"home_unknown">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"relative_config_dir">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unreadable">;
+            path: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unparseable">;
+            path: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"foreign_pid_domain">;
+            path: z.ZodString;
+            pid_domain: z.ZodString;
+            source: z.ZodEnum<{
+                session_file: "session_file";
+                roster_worker: "roster_worker";
+            }>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>], "kind">;
+    entries: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodEnum<{
+            repo: "repo";
+            reference: "reference";
+        }>;
+        dir: z.ZodString;
+        url: z.ZodString;
+        writable: z.ZodBoolean;
+        archived: z.ZodBoolean;
+        visibility: z.ZodNullable<z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>>;
+        ci: z.ZodBoolean;
+        branch: z.ZodNullable<z.ZodString>;
+        pinned: z.ZodBoolean;
+        refresh: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"act">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"held">;
+            by: z.ZodEnum<{
+                entry: "entry";
+                pinned: "pinned";
+                origin_not_https: "origin_not_https";
+            }>;
+        }, z.core.$strict>], "kind">>;
+        presence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"present">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"not_a_repo">;
+        }, z.core.$strict>], "kind">;
+        clone: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"act">;
+            recipe: z.ZodObject<{
+                url: z.ZodString;
+                branch: z.ZodNullable<z.ZodString>;
+                shallow: z.ZodBoolean;
+                sparse: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"held">;
+            recipe: z.ZodObject<{
+                url: z.ZodString;
+                branch: z.ZodNullable<z.ZodString>;
+                shallow: z.ZodBoolean;
+                sparse: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            by: z.ZodEnum<{
+                entry: "entry";
+                unprobed_worktree: "unprobed_worktree";
+                busy: "busy";
+            }>;
+        }, z.core.$strict>], "kind">>;
+        layout: z.ZodNullable<z.ZodObject<{
+            shallow: z.ZodBoolean;
+            sparse: z.ZodBoolean;
+            partial_filter: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        checkouts: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            primary: z.ZodBoolean;
+            head: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"branch">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"detached">;
+                commit: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            uncommitted: z.ZodObject<{
+                staged: z.ZodNumber;
+                unstaged: z.ZodNumber;
+                untracked: z.ZodNumber;
+                conflicted: z.ZodNumber;
+            }, z.core.$strict>;
+            in_progress: z.ZodNullable<z.ZodEnum<{
+                rebase: "rebase";
+                merge: "merge";
+                cherry_pick: "cherry_pick";
+                revert: "revert";
+                bisect: "bisect";
+                sequencer: "sequencer";
+                am: "am";
+            }>>;
+            locked: z.ZodBoolean;
+            linked: z.ZodBoolean;
+            submodules: z.ZodNullable<z.ZodBoolean>;
+            busy: z.ZodArray<z.ZodObject<{
+                pid: z.ZodNumber;
+                cwd: z.ZodString;
+                worktree: z.ZodNullable<z.ZodString>;
+                process_cwd: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    session_file: "session_file";
+                    roster_worker: "roster_worker";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        branches: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            upstream: z.ZodNullable<z.ZodString>;
+            worktree: z.ZodNullable<z.ZodString>;
+            symref: z.ZodNullable<z.ZodString>;
+            unique_commits: z.ZodNumber;
+            newest_commit_at: z.ZodNumber;
+            relation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"in_sync">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ahead">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"behind">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"diverged">;
+                ahead: z.ZodNumber;
+                behind: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"shallow">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"gone">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unmapped">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"untracked">;
+            }, z.core.$strict>], "kind">;
+            verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"quiet">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"act">;
+                action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"push">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fast_forward">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"move">;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"held">;
+                action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"push">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fast_forward">;
+                    commits: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"move">;
+                }, z.core.$strict>], "kind">;
+                by: z.ZodEnum<{
+                    entry: "entry";
+                    pinned: "pinned";
+                    push_url: "push_url";
+                    fetch_failed: "fetch_failed";
+                    dirty_checkout: "dirty_checkout";
+                    unprobed_worktree: "unprobed_worktree";
+                    several_checkouts: "several_checkouts";
+                    busy: "busy";
+                    busy_unknown: "busy_unknown";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"needs_human">;
+                reason: z.ZodEnum<{
+                    diverged: "diverged";
+                    unmapped: "unmapped";
+                    archived_ahead: "archived_ahead";
+                    shallow_local_work: "shallow_local_work";
+                    upstream_not_a_branch: "upstream_not_a_branch";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"local_only">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"cleanup">;
+                reason: z.ZodEnum<{
+                    merged: "merged";
+                    upstream_gone: "upstream_gone";
+                }>;
+                removable_worktree: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+        at_rest: z.ZodNullable<z.ZodObject<{
+            on_branch: z.ZodNullable<z.ZodBoolean>;
+            clean: z.ZodBoolean;
+            idle: z.ZodBoolean;
+            followed: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"in_sync">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ahead">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"behind">;
+                commits: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"diverged">;
+                ahead: z.ZodNumber;
+                behind: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"shallow">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"gone">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unmapped">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"untracked">;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+        stashes: z.ZodNumber;
+        fetched_at: z.ZodNullable<z.ZodNumber>;
+        needs_human: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"not_a_repo">;
+            detail: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"operation_in_progress">;
+            checkout: z.ZodString;
+            op: z.ZodEnum<{
+                rebase: "rebase";
+                merge: "merge";
+                cherry_pick: "cherry_pick";
+                revert: "revert";
+                bisect: "bisect";
+                sequencer: "sequencer";
+                am: "am";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_mismatch">;
+            origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"url">;
+                url: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"no_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing">;
+            }, z.core.$strict>], "kind">;
+            expected: z.ZodString;
+            fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"add">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+                reason: z.ZodEnum<{
+                    outside_repo_file: "outside_repo_file";
+                    valueless_url: "valueless_url";
+                    empty_value: "empty_value";
+                    several_urls: "several_urls";
+                }>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_not_https">;
+            fetch_url: z.ZodString;
+            expected: z.ZodString;
+            fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"add">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+                reason: z.ZodEnum<{
+                    outside_repo_file: "outside_repo_file";
+                    valueless_url: "valueless_url";
+                    empty_value: "empty_value";
+                    several_urls: "several_urls";
+                }>;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fetch_url_mismatch">;
+            fetch_url: z.ZodString;
+            expected: z.ZodString;
+            fix: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"add">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_url">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+                reason: z.ZodEnum<{
+                    outside_repo_file: "outside_repo_file";
+                    valueless_url: "valueless_url";
+                    empty_value: "empty_value";
+                    several_urls: "several_urls";
+                }>;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"worktree_unreadable">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"default_branch_missing">;
+            branch: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"default_branch_no_upstream">;
+            branch: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"default_branch_gone">;
+            branch: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unexpected_detached">;
+            checkout: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"checkout_unresolvable">;
+            checkout: z.ZodString;
+            path: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unlisted_git_dir">;
+            git_dir: z.ZodString;
+            head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"branch">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"detached">;
+                commit: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            busy: z.ZodArray<z.ZodObject<{
+                pid: z.ZodNumber;
+                cwd: z.ZodString;
+                worktree: z.ZodNullable<z.ZodString>;
+                process_cwd: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    session_file: "session_file";
+                    roster_worker: "roster_worker";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"push_url_mismatch">;
+            push_urls: z.ZodArray<z.ZodString>;
+            expected: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"clone_shares_repo">;
+            with: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"cloned_unregistered">;
+            dir: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        probe_error: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                path_unreadable: "path_unreadable";
+                non_utf8_path: "non_utf8_path";
+                config_unreadable: "config_unreadable";
+                fetch_url_unreadable: "fetch_url_unreadable";
+                push_urls_unreadable: "push_urls_unreadable";
+                git_not_run: "git_not_run";
+                git_timed_out: "git_timed_out";
+                git_failed: "git_failed";
+                unexpected_output: "unexpected_output";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        unprobed_worktrees: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            git_dir: z.ZodNullable<z.ZodString>;
+            head: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"branch">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"detached">;
+                commit: z.ZodString;
+            }, z.core.$strict>], "kind">>;
+            locked: z.ZodBoolean;
+            in_progress: z.ZodNullable<z.ZodEnum<{
+                rebase: "rebase";
+                merge: "merge";
+                cherry_pick: "cherry_pick";
+                revert: "revert";
+                bisect: "bisect";
+                sequencer: "sequencer";
+                am: "am";
+            }>>;
+            why: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"prunable">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"failed">;
+                error: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            holds: z.ZodNullable<z.ZodObject<{
+                submodules: z.ZodBoolean;
+                worktree_refs: z.ZodBoolean;
+                staged: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            prune: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"safe">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"loses">;
+                losses: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"operation">;
+                    op: z.ZodEnum<{
+                        rebase: "rebase";
+                        merge: "merge";
+                        cherry_pick: "cherry_pick";
+                        revert: "revert";
+                        bisect: "bisect";
+                        sequencer: "sequencer";
+                        am: "am";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"detached_head">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"unknown_head">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"missing_branch">;
+                    name: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"submodules">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"worktree_refs">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"staged_changes">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"unmatched_git_dir">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"relative_gitdir">;
+                    git_dir: z.ZodString;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"moved">;
+                to: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>], "kind">>;
+            busy: z.ZodArray<z.ZodObject<{
+                pid: z.ZodNumber;
+                cwd: z.ZodString;
+                worktree: z.ZodNullable<z.ZodString>;
+                process_cwd: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    session_file: "session_file";
+                    roster_worker: "roster_worker";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        fetch_error: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"ref_gone">;
+            refname: z.ZodString;
+            fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"unset_refspec">;
+                pattern: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"set_branches">;
+                branch: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"by_hand">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unreachable">;
+            cause: z.ZodEnum<{
+                dns: "dns";
+                connection: "connection";
+                host_key: "host_key";
+                auth: "auth";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"repo_not_found">;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"timed_out">;
+            after_secs: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"refspec_outside_origin">;
+            refspec: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"origin_refs_shared">;
+            remote: z.ZodString;
+            refspec: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+            path: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        visibility_check: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"leak">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"private">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+            failure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"ref_gone">;
+                refname: z.ZodString;
+                fix: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"unset_refspec">;
+                    pattern: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"set_branches">;
+                    branch: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"by_hand">;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unreachable">;
+                cause: z.ZodEnum<{
+                    dns: "dns";
+                    connection: "connection";
+                    host_key: "host_key";
+                    auth: "auth";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"repo_not_found">;
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"timed_out">;
+                after_secs: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"failed">;
+                message: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"refspec_outside_origin">;
+                refspec: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"origin_refs_shared">;
+                remote: z.ZodString;
+                refspec: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"legacy_remotes_unreadable">;
+                path: z.ZodString;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>>;
+    unregistered: z.ZodNullable<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"clone">;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"worktree">;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"moved_worktree">;
+        entry: z.ZodString;
+        blocked_by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"rewrites">;
+            path: z.ZodString;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"claimed_dir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"swapped">;
+            git_dir: z.ZodString;
+            with: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"relative_gitdir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unreadable_gitdir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"non_utf8_path">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"nul_in_gitdir">;
+            git_dir: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        exit_noise: z.ZodNullable<z.ZodString>;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"orphaned_worktree">;
+        entry: z.ZodString;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"shared_git_dir">;
+        entry: z.ZodString;
+        with: z.ZodNullable<z.ZodString>;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unfinished_clone">;
+        dir: z.ZodString;
+        origin: z.ZodNullable<z.ZodString>;
+        owned: z.ZodBoolean;
+    }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<18>;
+    error: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"references_with_targets">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"root_not_found">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_not_found">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"root_in_entry">;
+        key: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_read">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_parse">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"registry_invalid">;
+        issues: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"repo_not_owned">;
+            key: z.ZodString;
+            account: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fork_not_owned">;
+            key: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"dir_not_a_name">;
+            entry: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+            dir: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"dir_claimed_twice">;
+            dir: z.ZodString;
+            first: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+            second: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"key_in_both">;
+            key: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"key_is_other_dir">;
+            key: z.ZodString;
+            entry: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repo: "repo";
+                    reference: "reference";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown_checkout_ref">;
+            key: z.ZodString;
+            field: z.ZodEnum<{
+                requires: "requires";
+                consults: "consults";
+            }>;
+            target: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self_ref">;
+            key: z.ZodString;
+            field: z.ZodEnum<{
+                requires: "requires";
+                consults: "consults";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"requires_and_consults">;
+            key: z.ZodString;
+            target: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"git_not_found">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"git_too_old">;
+        found: z.ZodString;
+        required: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown_entry">;
+        name: z.ZodString;
+        suggestions: z.ZodArray<z.ZodString>;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"io">;
+        message: z.ZodString;
+        hint: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>]>;
+export type ReposStatusDocument = z.infer<typeof ReposStatusDocument>;
+//# sourceMappingURL=repos_status.d.ts.map