@maycombhq/sdk 2.0.0-beta.18 → 2.0.0-beta.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/npm/core/ai-decisions.d.ts +360 -0
- package/npm/core/api.d.ts +2811 -122
- package/npm/core/audit.d.ts +16 -4
- package/npm/core/catalog.d.ts +218 -66
- package/npm/core/decision-batches.d.ts +29 -0
- package/npm/core/declared-links.d.ts +62 -0
- package/npm/core/eol.d.ts +5 -0
- package/npm/core/facts-join.d.ts +66 -1
- package/npm/core/fs.d.ts +22 -3
- package/npm/core/host-questions.d.ts +5 -0
- package/npm/core/index.d.ts +7 -0
- package/npm/core/link-candidates.d.ts +103 -0
- package/npm/core/manifest-edit.d.ts +40 -0
- package/npm/core/merge.d.ts +19 -0
- package/npm/core/metarepo.d.ts +9 -0
- package/npm/core/orgpack-defaults.d.ts +7 -2
- package/npm/core/orgpack-load.d.ts +3 -0
- package/npm/core/question-roles.d.ts +24 -0
- package/npm/core/questions.d.ts +25 -2
- package/npm/core/runtime-migrate.d.ts +9 -0
- package/npm/core/schema/ai.d.ts +28 -7
- package/npm/core/schema/common.d.ts +32 -8
- package/npm/core/schema/component-type.d.ts +193 -0
- package/npm/core/schema/fact-corrections.d.ts +95 -2
- package/npm/core/schema/facts.d.ts +114 -2
- package/npm/core/schema/kinds.d.ts +228 -66
- package/npm/core/schema/orgpack.d.ts +43 -5
- package/npm/core/schema/question.d.ts +151 -6
- package/npm/core/schema/reading-rules.d.ts +51 -0
- package/npm/core/schema/review.d.ts +7 -7
- package/npm/core/schema/scan-verify.d.ts +42 -0
- package/npm/core/schema/version.d.ts +3 -1
- package/npm/index.js +4679 -2672
- package/package.json +1 -1
package/npm/core/api.d.ts
CHANGED
|
@@ -130,8 +130,175 @@ import { z } from "zod";
|
|
|
130
130
|
* calls. Additive only.
|
|
131
131
|
* 2.50.0 (ADR 0172): the contract check's counts give `unlinked`, the calls no link starts at.
|
|
132
132
|
* Additive only.
|
|
133
|
+
* 2.51.0: the questions list gives `counts` by state. Additive only.
|
|
134
|
+
* 2.52.0 (ADR 0173): an unattended Copilot run started from the app: POST /api/copilot-runs,
|
|
135
|
+
* GET /api/copilot-runs/current, POST /api/copilot-runs/{runId}/stop, and the live events
|
|
136
|
+
* `copilot-run.state` and `copilot-run.lines`. Additive only.
|
|
137
|
+
* 2.53.0 (ADR 0174): correcting the map on the canvas. GET /api/links/candidates and POST
|
|
138
|
+
* /api/links/connect (G1, a call paired with an API, a `link` line in the caller's
|
|
139
|
+
* corrections, and `person` among a link's hows); POST /api/facts/{repo}/corrections/undo;
|
|
140
|
+
* GET and PUT /api/repos/{repo}/owner (G2); POST /api/declared-links and its undo, GET
|
|
141
|
+
* /api/boxes/addable, POST /api/boxes, GET /api/boxes/corrections (G3). Additive only.
|
|
142
|
+
* 2.54.0 (ADR 0175): GET /api/graph/views and PUT /api/graph/views/{name}, a canvas's named
|
|
143
|
+
* filters and layers kept in the metarepo; GET /api/code-link, a cited line's file to open in
|
|
144
|
+
* an editor. Additive only.
|
|
145
|
+
* 2.55.0 (ADR 0176): POST /api/reading-rules/from-pairing, a draft reading rule for the repo's
|
|
146
|
+
* type from a call a person paired. Additive only.
|
|
147
|
+
* 2.56.0 (ADR 0173, review): GET /api/copilot-runs/current takes `tail` (each tab's last lines,
|
|
148
|
+
* 200 by default; 0 for all) and GET /api/copilot-runs/{runId}/tabs/{tab}?from=N gives a tab's
|
|
149
|
+
* lines from a line on; GET /api/links/candidates says `why: unverified` on noCalls and noApis
|
|
150
|
+
* for a repo whose facts aren't all verified; PUT /api/graph/views/{name} replaces a view kept
|
|
151
|
+
* already only with `replace=1` (409 otherwise). A changed file is 409 on every write.
|
|
152
|
+
* 2.57.0 (ADR 0178): GET /api/links/candidates gives each call its likeliest APIs (`suggestions`,
|
|
153
|
+
* at most three) and `confident` on a sure one; an API carries `words` (an operationId) and a
|
|
154
|
+
* gateway route `forwards`; more ways a call is matched (its settings filled in, a version
|
|
155
|
+
* prefix, the operation's name, what a route forwards to). Additive only.
|
|
156
|
+
* 2.58.0 (ADR 0179): GET and POST /api/changes/{changeId}/sketch, a change drawn on the canvas
|
|
157
|
+
* stroke by stroke into its target flows. Additive only.
|
|
158
|
+
* 2.59.0 (ADR 0178, part 2): GET and POST /api/links/match, Copilot's proposed pairings of box
|
|
159
|
+
* A's calls with box B's APIs, checked and never written by the session. Additive only.
|
|
160
|
+
* 2.60.0 (ADR 0180): GET /api/component-types, the organisation's component types (Atticus's
|
|
161
|
+
* built-ins with the org pack's own, reworded and switched-off ones applied), each with how
|
|
162
|
+
* the canvas draws it, its signals, what it must and must not do, and its notes. Additive only.
|
|
163
|
+
* 2.61.0 (ADR 0036 addendum, review): a run's view carries `taskRun`, the task run it is part
|
|
164
|
+
* of (its state, notes, worktree, last build log and commit); POST /api/runs/{runId}/done on a
|
|
165
|
+
* task run's hand-off builds, fixes and commits as `atticus handoff done` does. Additive only.
|
|
166
|
+
* 2.62.0 (review): PUT /api/repos/{repoId}/branches and /description take `was`, what the form
|
|
167
|
+
* showed; a manifest changed since (a teammate's pull) is 409, never written over. Additive.
|
|
168
|
+
* 2.63.0 (review): GET /api/catalog/{kind} takes `confidence`, so a page counts the verified
|
|
169
|
+
* records of a large estate by `total` instead of reading them all. Additive only.
|
|
170
|
+
* 2.64.0 (UX review): GET /api/change-types, the org pack's change types for the app's New change
|
|
171
|
+
* form (POST /api/changes was there; nothing listed what `type` could be). Additive only.
|
|
172
|
+
* 2.65.0 (ADR 0183): POST /api/facts/{repo}/apply runs verify --write; GET and POST
|
|
173
|
+
* /api/propose list what a kind of work changed and, on the person's yes, push it to a branch
|
|
174
|
+
* and open the PR. Additive only.
|
|
175
|
+
* 2.66.0 (UX review, round 35): POST /api/runs/handoff prepares a step for the person's own
|
|
176
|
+
* assistant (201 with its run) where no model is configured; POST /api/propose/bring-in
|
|
177
|
+
* brings in what merged; a proposal takes the branch it was shown; a hand-off's ChangeDetail
|
|
178
|
+
* carries its `notes`. Apply, Propose and Bring in answer 202 with a job (an editor panel
|
|
179
|
+
* waits 30 s for one answer). Additive only.
|
|
180
|
+
* 2.67.0 (UX review, 2026-11-08): the knowledge gaps' owner questions answered in the app:
|
|
181
|
+
* GET /api/owner-questions and POST /api/owner-questions/{id}/answer (writing
|
|
182
|
+
* catalog/curated/ownerquestion/<id>.yaml, as atticus questions owner); ProposeScope adds
|
|
183
|
+
* owner-answers and baseline. POST /api/initiatives, POST /api/initiatives/{initiativeId}/plan
|
|
184
|
+
* and POST /api/commitments/{commitmentId}/status start, plan and record initiatives as the
|
|
185
|
+
* signed-in person (as atticus initiative new|plan|commit); a commitment's status carries its
|
|
186
|
+
* latest note; ProposeScope adds initiatives and outcomes, and (UX re-walk) work, everything
|
|
187
|
+
* the app's work writes. POST /api/changes/{changeId}/prototypes compares a prototype and
|
|
188
|
+
* attaches it, as change attach --prototype (GET adds `candidates`); PUT
|
|
189
|
+
* /api/service-desk/{changeId}/fields fills a draft's fields in snow.md, 409 if it changed
|
|
190
|
+
* since read (GET requests carry `file` and `sha256`); ProposeScope adds service-desk; POST
|
|
191
|
+
* /api/runs and /api/runs/handoff accept `--source <wiki>` on knowledge scan and find.
|
|
192
|
+
* Additive only. Round 37: a job's kind may be `local` (Apply, Propose, Bring in), and a
|
|
193
|
+
* proposal plan's file says when it is already `proposed`.
|
|
194
|
+
* 2.68.0 (review round 41): one AI step and one local step at a time. POST /api/runs answers 409
|
|
195
|
+
* while another AI step runs on the server, and POST /api/facts/{repo}/apply, POST
|
|
196
|
+
* /api/propose and POST /api/propose/bring-in answer 409 while another local step (Apply,
|
|
197
|
+
* Propose, Bring in) runs; each problem names the job that runs. Additive only.
|
|
198
|
+
* 2.69.0 (sixth UX walk, screens): a task in GET /api/changes/{changeId}/tasks carries
|
|
199
|
+
* `taskRun`, where its Run with AI stands (drafted, unverified, PR open, waiting), and `run`,
|
|
200
|
+
* its latest run; POST /api/changes/{changeId}/tasks/{taskId}/pr raises a drafted task's PR on
|
|
201
|
+
* the person's click (the push and PR the pr level makes, the AI step not run again); GET
|
|
202
|
+
* /api/propose lists `applyFirst`, the repos whose corrections are newer than their last
|
|
203
|
+
* Apply. Additive only.
|
|
204
|
+
* 2.70.0 (seventh UX walk, answers and access): a change's artifact in GET
|
|
205
|
+
* /api/changes/{changeId} carries `written`, whether its file is there (a status of ready or
|
|
206
|
+
* blocked says what the phase allows, not that the file was written); GET /api/propose lists in
|
|
207
|
+
* `applyFirst` the repos whose answered map questions are newer than their last Apply too, not
|
|
208
|
+
* only their corrections. Additive only.
|
|
209
|
+
* 2.71.0 (review round 43): a task's raised PR in GET /api/changes/{changeId}/tasks carries
|
|
210
|
+
* `taskRun.pr.state`, open, merged or closed as the Git host says it now (asked read-only, with
|
|
211
|
+
* a short timeout; absent when the host can't say). Additive only.
|
|
212
|
+
* 2.72.0 (seventh UX walk, what's next): GET /api/changes/{changeId}/cockpit's `next` follows
|
|
213
|
+
* the change's state and gate, never a later stage: a raised hand-off's step is `merge` and
|
|
214
|
+
* carries `pr`, the PR it waits on (a manual Git host's manual:// placeholder too, which a page
|
|
215
|
+
* never shows as a link); every task ticked is the state's `handoff`. A manual Git host's
|
|
216
|
+
* hand-off PR not opened yet is said as a step waiting on a person in `nextStep` and the
|
|
217
|
+
* `pr-not-merged` reason, never its manual:// URL. Additive only.
|
|
218
|
+
* 2.73.0 (seventh UX walk, release; ADR 0184): POST /api/changes/{changeId}/release-prs raises
|
|
219
|
+
* one release PR per code repo from change/<id> into its default branch on the person's click,
|
|
220
|
+
* recorded in repos.yaml (`pr`); POST /api/changes/{changeId}/sync also reads the release PRs
|
|
221
|
+
* back; the archive gate's blockers add `pr-missing`, `not-synced`, `needs-reading` and
|
|
222
|
+
* `catalog-stale`, and the readers' drift becomes a note (ADR 0074). Additive only.
|
|
223
|
+
* 2.74.0 (seventh UX walk, setup and stories): a repo in GET /api/repos/branches carries `build`,
|
|
224
|
+
* its build command from the manifest; PUT /api/repos/{repoId}/build sets or clears it, and PUT
|
|
225
|
+
* /api/orgpack/owner sets who looks after the org pack (pack.yaml's owner), each on a person's
|
|
226
|
+
* click and written to the file the person then proposes; GET and PUT
|
|
227
|
+
* /api/changes/{changeId}/artifacts/{artifact} take `?file=`, one file of a many-file artifact
|
|
228
|
+
* (a story under stories/, a spec), so each story can be read and edited. Additive only.
|
|
229
|
+
* 2.75.0 (seventh UX walk, tasks and manual steps): POST
|
|
230
|
+
* /api/changes/{changeId}/tasks/{taskId}/done ticks or unticks a task in tasks.md on the
|
|
231
|
+
* person's click; GET /api/changes/{changeId}/tasks ticks a task whose PR merged on the Git host
|
|
232
|
+
* (once) and says so in `taskRun.ticked`, and a raised PR's number and link are the host's (a
|
|
233
|
+
* manual host's as the person recorded them); POST /api/todo/{stepId}/done syncs the change's
|
|
234
|
+
* open hand-off after a Git host step and returns what it said in `synced` (read-only: never a
|
|
235
|
+
* merge). Additive only.
|
|
236
|
+
* 2.76.0 (eighth UX walk, code against design): POST /api/changes/{changeId}/conformance checks
|
|
237
|
+
* the code against the design again on the person's click (as atticus change conform), a local
|
|
238
|
+
* step that answers 202 with its job (409 while another local step runs). The check rests on
|
|
239
|
+
* facts (rule 4): what a repo's facts don't cover at the branch's commit (files changed since
|
|
240
|
+
* the read, or a repo read only by the built-in readers) is never `missing`; it is under
|
|
241
|
+
* `unchecked`, saying it couldn't be confirmed from the code. Additive only.
|
|
242
|
+
* 2.77.0 (eighth UX walk, stage pages and access): GET and PUT
|
|
243
|
+
* /api/changes/{changeId}/placement, the feature stage's placement (feature.md as the page
|
|
244
|
+
* shows it, feature.yaml as a person edits it) with who drafted it last (`drafted`: the AI at
|
|
245
|
+
* the feature stage, or a person's save); a task's `taskRun.marked`, who last ticked or
|
|
246
|
+
* unticked it by hand on the Task board, so a task Atticus ticked and a person ticked again says
|
|
247
|
+
* who. Additive only.
|
|
248
|
+
* 2.78.0 (eighth UX walk, hand-off clicks; ADR 0185): a run in GET /api/runs, GET /api/runs/{runId}
|
|
249
|
+
* and its transcript carries `parts` when it is a batched hand-off (a stage's critic lenses in one
|
|
250
|
+
* prompt: each lens's name, its own run and that run's state) and `batch` when it is one of those
|
|
251
|
+
* lenses' own runs (run record version 6). POST /api/runs/{runId}/done on a batch checks each
|
|
252
|
+
* lens's section on its own and reads in those that pass; a stage's draft Done offers the batch as
|
|
253
|
+
* its `next`. Additive only.
|
|
254
|
+
* 2.79.0 (ADR 0181 part 4, a change ends at the tech lead or architect): role-owned questions.
|
|
255
|
+
* GET /api/questions takes `role` (product, architecture, analysis, delivery) and `change` (a
|
|
256
|
+
* change's questions, wherever they are filed), and says each question's `about.role`,
|
|
257
|
+
* `counts.byRole` and, with change=, `yourRoles` (the person's roles from change.yaml's owners);
|
|
258
|
+
* a question file at version 5 may carry `role`. The cockpit says `openQuestionsByRole` and
|
|
259
|
+
* `yourRoles`. Run all ready tasks: GET /api/changes/{changeId}/tasks/ready and POST
|
|
260
|
+
* /api/changes/{changeId}/tasks/run-ready, one task run per ready task in cross-repo order as
|
|
261
|
+
* one job, stopping on the first that needs a person; the click is the approval for draft,
|
|
262
|
+
* never the pr level; nothing is merged. Additive only.
|
|
263
|
+
* 2.80.0 (ADR 0181, stage drafts: AI-drafted, corrections carried): GET
|
|
264
|
+
* /api/changes/{changeId}/drafts/{page}, a page's stage drafts with who wrote each last (the AI
|
|
265
|
+
* with its stage and run, from stage/drafted.yaml, until a person saves it) and the items a
|
|
266
|
+
* person can correct; GET and POST /api/changes/{changeId}/corrections and POST
|
|
267
|
+
* .../corrections/{correctionId}/remove, a person's corrections (stage/corrections.yaml), which
|
|
268
|
+
* the stage's next run reads as the person's word, for the item or every similar one, and marks
|
|
269
|
+
* applied. A save through PUT .../artifacts/{artifact} or .../placement records who saved it.
|
|
270
|
+
* Additive only.
|
|
271
|
+
* 2.81.0 (ADR 0181, AI decides first): GET /api/decisions lists the AI's decisions that stand
|
|
272
|
+
* (pairings flagged `joined-by-ai`, answers `by: { kind: ai, runtime, run }`), with counts split
|
|
273
|
+
* from code, by a person and by AI, the batches, and whether deciding is on or paused by the
|
|
274
|
+
* sample audit (with why); POST /api/decisions/correct records a person's correction and spreads
|
|
275
|
+
* it by a rule (preview first); POST /api/decisions/batches/{batchId}/undo undoes one batch.
|
|
276
|
+
* `MatchLinksView.decided` says what Atticus applied from a Copilot match; a Question's answer's
|
|
277
|
+
* `by` may be the AI's, with `batch` and `rule`; a corrections line may carry `ai`, `batch`,
|
|
278
|
+
* `rule`, `match` and the action `unlink`; TrustRepo.audit gains `ai`; an Interface's evidence
|
|
279
|
+
* may be `source: ai` with `run`. Additive only.
|
|
280
|
+
* 2.82.0 (ADR 0181, the canvas's Detected by AI layer): a graph join's `how` may be `ai` (a call
|
|
281
|
+
* the AI paired, its Interface flagged `joined-by-ai`), with the deciding `run`, so the canvas
|
|
282
|
+
* draws, filters and counts the AI's links apart from the code's and a person's. Additive only.
|
|
283
|
+
* 2.83.0 (ninth UX walk): PUT /api/changes/{changeId}/owners names a change's owners per role
|
|
284
|
+
* (product owner, architect, business analyst, tech lead) in change.yaml; ChangeDetail gains
|
|
285
|
+
* `owners`; a Task gains `waits` (the tasks it waits for, `sameRepo` its own repo's) and a
|
|
286
|
+
* ReadyTasks task `sameRepo`; an OwnerQuestionView may carry `finding` (a critic knowledge gap a
|
|
287
|
+
* person asked of its owner), and /api/questions leaves those out (they are owner questions).
|
|
288
|
+
* Additive only.
|
|
289
|
+
* 2.84.0 (ADR 0181, ninth UX walk): AI decides in hand-off mode too. `MatchLinksView.run` is the
|
|
290
|
+
* hand-off run a Match's brief waits on, and POST /api/links/match/done reads its answer in and
|
|
291
|
+
* decides from it as the AI's (runtime `hand-off`, with the run); GET and POST
|
|
292
|
+
* /api/propose-answers hand the open questions to the person's assistant as a hand-off run,
|
|
293
|
+
* whose Done (POST /api/runs/{runId}/done) decides from its proposals the same way. An AI
|
|
294
|
+
* decision's runtime may be `hand-off`. `DecideStateView.decideIn` says which runs decide here,
|
|
295
|
+
* as runtime.yaml allows them; `DecisionCounts.retired` counts retired questions apart;
|
|
296
|
+
* `DecisionsView.links.lines` counts the standing pairings in the corrections, beside the map's
|
|
297
|
+
* as last applied. GET /api/settings/ai gives `decide` and `schemaVersion`, and PUT takes
|
|
298
|
+
* `decide` (lifting a version 3 file to 4). GET /api/upgrade lists the pending upgrade steps and
|
|
299
|
+
* POST /api/upgrade runs `atticus upgrade` as a local job on the person's click. Additive only.
|
|
133
300
|
*/
|
|
134
|
-
export declare const API_VERSION = "2.
|
|
301
|
+
export declare const API_VERSION = "2.84.0";
|
|
135
302
|
export declare const DEFAULT_PORT = 4321;
|
|
136
303
|
/** RFC 9457 problem details, used for every error. */
|
|
137
304
|
export declare const Problem: z.ZodObject<{
|
|
@@ -393,20 +560,24 @@ export declare const HIER_EDGE_TYPES: readonly ["calls", "publishes", "subscribe
|
|
|
393
560
|
* (written before 2.32.0, or by the built-in readers). 2.38.0 (J0, J1): the guesses a join by
|
|
394
561
|
* host can rest on, a `platform-setting` nobody aimed at the caller, a setting's `folder-name`,
|
|
395
562
|
* or a host or base path an open `conflict` disputes. 2.44.0 (J1): or a Kubernetes Service's
|
|
396
|
-
* short name (`service-name`) the caller's own cited namespace doesn't resolve.
|
|
563
|
+
* short name (`service-name`) the caller's own cited namespace doesn't resolve. 2.82.0 (ADR
|
|
564
|
+
* 0181): or `ai`, a pairing the AI decided (never a person's word; inferred until one corrects or
|
|
565
|
+
* confirms it).
|
|
397
566
|
*/
|
|
398
|
-
export declare const LINK_HOWS: readonly ["answer", "named", "repo", "host", "declared", "topic", "path", "label", "platform-setting", "folder-name", "conflict", "service-name", "shared", "unknown"];
|
|
567
|
+
export declare const LINK_HOWS: readonly ["person", "answer", "named", "repo", "host", "declared", "topic", "path", "label", "platform-setting", "folder-name", "conflict", "service-name", "shared", "ai", "unknown"];
|
|
399
568
|
export declare const HierJoin: z.ZodObject<{
|
|
400
569
|
interface: z.ZodString;
|
|
401
570
|
from: z.ZodString;
|
|
402
571
|
to: z.ZodString;
|
|
403
572
|
how: z.ZodEnum<{
|
|
404
573
|
unknown: "unknown";
|
|
574
|
+
ai: "ai";
|
|
405
575
|
repo: "repo";
|
|
406
576
|
path: "path";
|
|
407
577
|
host: "host";
|
|
408
578
|
label: "label";
|
|
409
579
|
answer: "answer";
|
|
580
|
+
person: "person";
|
|
410
581
|
declared: "declared";
|
|
411
582
|
shared: "shared";
|
|
412
583
|
topic: "topic";
|
|
@@ -446,6 +617,7 @@ export declare const HierJoin: z.ZodObject<{
|
|
|
446
617
|
at: z.ZodString;
|
|
447
618
|
commit: z.ZodOptional<z.ZodString>;
|
|
448
619
|
}, z.core.$strip>>;
|
|
620
|
+
run: z.ZodOptional<z.ZodString>;
|
|
449
621
|
}, z.core.$strip>;
|
|
450
622
|
/** Parallel edges between the same two nodes of the same type are one edge with a count. */
|
|
451
623
|
export declare const HierEdge: z.ZodObject<{
|
|
@@ -487,11 +659,13 @@ export declare const HierEdge: z.ZodObject<{
|
|
|
487
659
|
to: z.ZodString;
|
|
488
660
|
how: z.ZodEnum<{
|
|
489
661
|
unknown: "unknown";
|
|
662
|
+
ai: "ai";
|
|
490
663
|
repo: "repo";
|
|
491
664
|
path: "path";
|
|
492
665
|
host: "host";
|
|
493
666
|
label: "label";
|
|
494
667
|
answer: "answer";
|
|
668
|
+
person: "person";
|
|
495
669
|
declared: "declared";
|
|
496
670
|
shared: "shared";
|
|
497
671
|
topic: "topic";
|
|
@@ -531,6 +705,7 @@ export declare const HierEdge: z.ZodObject<{
|
|
|
531
705
|
at: z.ZodString;
|
|
532
706
|
commit: z.ZodOptional<z.ZodString>;
|
|
533
707
|
}, z.core.$strip>>;
|
|
708
|
+
run: z.ZodOptional<z.ZodString>;
|
|
534
709
|
}, z.core.$strip>>>;
|
|
535
710
|
}, z.core.$strip>;
|
|
536
711
|
/** GET /api/graph/node/{id}: a node, its children (lazy), and its edges inside and out. */
|
|
@@ -745,11 +920,13 @@ export declare const GraphNodeView: z.ZodObject<{
|
|
|
745
920
|
to: z.ZodString;
|
|
746
921
|
how: z.ZodEnum<{
|
|
747
922
|
unknown: "unknown";
|
|
923
|
+
ai: "ai";
|
|
748
924
|
repo: "repo";
|
|
749
925
|
path: "path";
|
|
750
926
|
host: "host";
|
|
751
927
|
label: "label";
|
|
752
928
|
answer: "answer";
|
|
929
|
+
person: "person";
|
|
753
930
|
declared: "declared";
|
|
754
931
|
shared: "shared";
|
|
755
932
|
topic: "topic";
|
|
@@ -789,6 +966,7 @@ export declare const GraphNodeView: z.ZodObject<{
|
|
|
789
966
|
at: z.ZodString;
|
|
790
967
|
commit: z.ZodOptional<z.ZodString>;
|
|
791
968
|
}, z.core.$strip>>;
|
|
969
|
+
run: z.ZodOptional<z.ZodString>;
|
|
792
970
|
}, z.core.$strip>>>;
|
|
793
971
|
}, z.core.$strip>>;
|
|
794
972
|
reduced: z.ZodBoolean;
|
|
@@ -972,11 +1150,13 @@ export declare const GraphFocusView: z.ZodObject<{
|
|
|
972
1150
|
to: z.ZodString;
|
|
973
1151
|
how: z.ZodEnum<{
|
|
974
1152
|
unknown: "unknown";
|
|
1153
|
+
ai: "ai";
|
|
975
1154
|
repo: "repo";
|
|
976
1155
|
path: "path";
|
|
977
1156
|
host: "host";
|
|
978
1157
|
label: "label";
|
|
979
1158
|
answer: "answer";
|
|
1159
|
+
person: "person";
|
|
980
1160
|
declared: "declared";
|
|
981
1161
|
shared: "shared";
|
|
982
1162
|
topic: "topic";
|
|
@@ -1016,6 +1196,7 @@ export declare const GraphFocusView: z.ZodObject<{
|
|
|
1016
1196
|
at: z.ZodString;
|
|
1017
1197
|
commit: z.ZodOptional<z.ZodString>;
|
|
1018
1198
|
}, z.core.$strip>>;
|
|
1199
|
+
run: z.ZodOptional<z.ZodString>;
|
|
1019
1200
|
}, z.core.$strip>>>;
|
|
1020
1201
|
}, z.core.$strip>>;
|
|
1021
1202
|
}, z.core.$strip>;
|
|
@@ -1097,6 +1278,8 @@ export declare const Impact: z.ZodObject<{
|
|
|
1097
1278
|
path: z.ZodArray<z.ZodString>;
|
|
1098
1279
|
reason: z.ZodString;
|
|
1099
1280
|
owner: z.ZodOptional<z.ZodString>;
|
|
1281
|
+
byAi: z.ZodOptional<z.ZodBoolean>;
|
|
1282
|
+
run: z.ZodOptional<z.ZodString>;
|
|
1100
1283
|
}, z.core.$strip>>;
|
|
1101
1284
|
gaps: z.ZodArray<z.ZodObject<{
|
|
1102
1285
|
record: z.ZodString;
|
|
@@ -1120,13 +1303,14 @@ export declare const Coverage: z.ZodObject<{
|
|
|
1120
1303
|
export declare const JobState: z.ZodEnum<{
|
|
1121
1304
|
done: "done";
|
|
1122
1305
|
failed: "failed";
|
|
1123
|
-
cancelled: "cancelled";
|
|
1124
1306
|
running: "running";
|
|
1307
|
+
cancelled: "cancelled";
|
|
1125
1308
|
queued: "queued";
|
|
1126
1309
|
}>;
|
|
1127
1310
|
export declare const Job: z.ZodObject<{
|
|
1128
1311
|
id: z.ZodString;
|
|
1129
1312
|
kind: z.ZodEnum<{
|
|
1313
|
+
local: "local";
|
|
1130
1314
|
sync: "sync";
|
|
1131
1315
|
index: "index";
|
|
1132
1316
|
step: "step";
|
|
@@ -1137,8 +1321,8 @@ export declare const Job: z.ZodObject<{
|
|
|
1137
1321
|
state: z.ZodEnum<{
|
|
1138
1322
|
done: "done";
|
|
1139
1323
|
failed: "failed";
|
|
1140
|
-
cancelled: "cancelled";
|
|
1141
1324
|
running: "running";
|
|
1325
|
+
cancelled: "cancelled";
|
|
1142
1326
|
queued: "queued";
|
|
1143
1327
|
}>;
|
|
1144
1328
|
progress: z.ZodObject<{
|
|
@@ -1175,6 +1359,7 @@ export declare const ArtifactStatus: z.ZodObject<{
|
|
|
1175
1359
|
ready: "ready";
|
|
1176
1360
|
"not-required": "not-required";
|
|
1177
1361
|
}>;
|
|
1362
|
+
written: z.ZodOptional<z.ZodBoolean>;
|
|
1178
1363
|
owner: z.ZodOptional<z.ZodString>;
|
|
1179
1364
|
openFindings: z.ZodNumber;
|
|
1180
1365
|
}, z.core.$strip>;
|
|
@@ -1245,6 +1430,8 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1245
1430
|
}, z.core.$strip>;
|
|
1246
1431
|
updatedAt: z.ZodString;
|
|
1247
1432
|
fastPath: z.ZodOptional<z.ZodBoolean>;
|
|
1433
|
+
notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1434
|
+
owners: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
|
|
1248
1435
|
artifacts: z.ZodArray<z.ZodObject<{
|
|
1249
1436
|
artifact: z.ZodEnum<{
|
|
1250
1437
|
interfaces: "interfaces";
|
|
@@ -1266,6 +1453,7 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1266
1453
|
ready: "ready";
|
|
1267
1454
|
"not-required": "not-required";
|
|
1268
1455
|
}>;
|
|
1456
|
+
written: z.ZodOptional<z.ZodBoolean>;
|
|
1269
1457
|
owner: z.ZodOptional<z.ZodString>;
|
|
1270
1458
|
openFindings: z.ZodNumber;
|
|
1271
1459
|
}, z.core.$strip>>;
|
|
@@ -1348,9 +1536,36 @@ export declare const Task: z.ZodObject<{
|
|
|
1348
1536
|
story: z.ZodOptional<z.ZodString>;
|
|
1349
1537
|
branch: z.ZodOptional<z.ZodString>;
|
|
1350
1538
|
run: z.ZodOptional<z.ZodString>;
|
|
1539
|
+
taskRun: z.ZodOptional<z.ZodObject<{
|
|
1540
|
+
state: z.ZodString;
|
|
1541
|
+
level: z.ZodString;
|
|
1542
|
+
branch: z.ZodString;
|
|
1543
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
1544
|
+
pr: z.ZodOptional<z.ZodObject<{
|
|
1545
|
+
number: z.ZodNumber;
|
|
1546
|
+
url: z.ZodString;
|
|
1547
|
+
state: z.ZodOptional<z.ZodEnum<{
|
|
1548
|
+
open: "open";
|
|
1549
|
+
merged: "merged";
|
|
1550
|
+
closed: "closed";
|
|
1551
|
+
}>>;
|
|
1552
|
+
}, z.core.$strip>>;
|
|
1553
|
+
ticked: z.ZodOptional<z.ZodString>;
|
|
1554
|
+
marked: z.ZodOptional<z.ZodObject<{
|
|
1555
|
+
done: z.ZodBoolean;
|
|
1556
|
+
by: z.ZodString;
|
|
1557
|
+
at: z.ZodString;
|
|
1558
|
+
}, z.core.$strip>>;
|
|
1559
|
+
notes: z.ZodArray<z.ZodString>;
|
|
1560
|
+
}, z.core.$strip>>;
|
|
1561
|
+
waits: z.ZodOptional<z.ZodObject<{
|
|
1562
|
+
tasks: z.ZodArray<z.ZodString>;
|
|
1563
|
+
sameRepo: z.ZodArray<z.ZodString>;
|
|
1564
|
+
}, z.core.$strip>>;
|
|
1351
1565
|
}, z.core.$strip>;
|
|
1566
|
+
export type TaskT = z.infer<typeof Task>;
|
|
1352
1567
|
export declare const RunView: z.ZodObject<{
|
|
1353
|
-
schemaVersion: z.ZodLiteral<
|
|
1568
|
+
schemaVersion: z.ZodLiteral<6>;
|
|
1354
1569
|
runId: z.ZodString;
|
|
1355
1570
|
change: z.ZodString;
|
|
1356
1571
|
agent: z.ZodString;
|
|
@@ -1432,12 +1647,36 @@ export declare const RunView: z.ZodObject<{
|
|
|
1432
1647
|
version: z.ZodOptional<z.ZodString>;
|
|
1433
1648
|
protocolVersion: z.ZodOptional<z.ZodNumber>;
|
|
1434
1649
|
}, z.core.$strict>>;
|
|
1650
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
1651
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1652
|
+
name: z.ZodString;
|
|
1653
|
+
runId: z.ZodString;
|
|
1654
|
+
state: z.ZodOptional<z.ZodEnum<{
|
|
1655
|
+
failed: "failed";
|
|
1656
|
+
prepared: "prepared";
|
|
1657
|
+
waiting: "waiting";
|
|
1658
|
+
produced: "produced";
|
|
1659
|
+
validated: "validated";
|
|
1660
|
+
cancelled: "cancelled";
|
|
1661
|
+
}>>;
|
|
1662
|
+
}, z.core.$strict>>>;
|
|
1435
1663
|
promptPath: z.ZodOptional<z.ZodString>;
|
|
1436
1664
|
workspaceFile: z.ZodOptional<z.ZodString>;
|
|
1665
|
+
taskRun: z.ZodOptional<z.ZodObject<{
|
|
1666
|
+
task: z.ZodString;
|
|
1667
|
+
repo: z.ZodString;
|
|
1668
|
+
level: z.ZodString;
|
|
1669
|
+
state: z.ZodString;
|
|
1670
|
+
branch: z.ZodString;
|
|
1671
|
+
worktree: z.ZodString;
|
|
1672
|
+
notes: z.ZodArray<z.ZodString>;
|
|
1673
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
1674
|
+
log: z.ZodOptional<z.ZodString>;
|
|
1675
|
+
}, z.core.$strip>>;
|
|
1437
1676
|
}, z.core.$strict>;
|
|
1438
1677
|
/** ADR 0106: one run in the list of model runs. */
|
|
1439
1678
|
export declare const RunListItem: z.ZodObject<{
|
|
1440
|
-
schemaVersion: z.ZodLiteral<
|
|
1679
|
+
schemaVersion: z.ZodLiteral<6>;
|
|
1441
1680
|
runId: z.ZodString;
|
|
1442
1681
|
change: z.ZodString;
|
|
1443
1682
|
agent: z.ZodString;
|
|
@@ -1518,8 +1757,32 @@ export declare const RunListItem: z.ZodObject<{
|
|
|
1518
1757
|
version: z.ZodOptional<z.ZodString>;
|
|
1519
1758
|
protocolVersion: z.ZodOptional<z.ZodNumber>;
|
|
1520
1759
|
}, z.core.$strict>>;
|
|
1760
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
1761
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1762
|
+
name: z.ZodString;
|
|
1763
|
+
runId: z.ZodString;
|
|
1764
|
+
state: z.ZodOptional<z.ZodEnum<{
|
|
1765
|
+
failed: "failed";
|
|
1766
|
+
prepared: "prepared";
|
|
1767
|
+
waiting: "waiting";
|
|
1768
|
+
produced: "produced";
|
|
1769
|
+
validated: "validated";
|
|
1770
|
+
cancelled: "cancelled";
|
|
1771
|
+
}>>;
|
|
1772
|
+
}, z.core.$strict>>>;
|
|
1521
1773
|
promptPath: z.ZodOptional<z.ZodString>;
|
|
1522
1774
|
workspaceFile: z.ZodOptional<z.ZodString>;
|
|
1775
|
+
taskRun: z.ZodOptional<z.ZodObject<{
|
|
1776
|
+
task: z.ZodString;
|
|
1777
|
+
repo: z.ZodString;
|
|
1778
|
+
level: z.ZodString;
|
|
1779
|
+
state: z.ZodString;
|
|
1780
|
+
branch: z.ZodString;
|
|
1781
|
+
worktree: z.ZodString;
|
|
1782
|
+
notes: z.ZodArray<z.ZodString>;
|
|
1783
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
1784
|
+
log: z.ZodOptional<z.ZodString>;
|
|
1785
|
+
}, z.core.$strip>>;
|
|
1523
1786
|
attempt: z.ZodNumber;
|
|
1524
1787
|
answered: z.ZodBoolean;
|
|
1525
1788
|
handedBack: z.ZodNumber;
|
|
@@ -1531,10 +1794,129 @@ export type RunListItem = z.infer<typeof RunListItem>;
|
|
|
1531
1794
|
export declare const StartStepRequest: z.ZodObject<{
|
|
1532
1795
|
args: z.ZodArray<z.ZodString>;
|
|
1533
1796
|
}, z.core.$strip>;
|
|
1797
|
+
/** 2.67.0: what Done did: the run, what it printed, and the step's next run when it offers one. */
|
|
1798
|
+
export declare const RunDoneView: z.ZodObject<{
|
|
1799
|
+
schemaVersion: z.ZodLiteral<6>;
|
|
1800
|
+
runId: z.ZodString;
|
|
1801
|
+
change: z.ZodString;
|
|
1802
|
+
agent: z.ZodString;
|
|
1803
|
+
runtime: z.ZodEnum<{
|
|
1804
|
+
model: "model";
|
|
1805
|
+
"hand-off": "hand-off";
|
|
1806
|
+
"headless-claude-code": "headless-claude-code";
|
|
1807
|
+
"copilot-acp": "copilot-acp";
|
|
1808
|
+
mock: "mock";
|
|
1809
|
+
replay: "replay";
|
|
1810
|
+
}>;
|
|
1811
|
+
state: z.ZodEnum<{
|
|
1812
|
+
failed: "failed";
|
|
1813
|
+
prepared: "prepared";
|
|
1814
|
+
waiting: "waiting";
|
|
1815
|
+
produced: "produced";
|
|
1816
|
+
validated: "validated";
|
|
1817
|
+
cancelled: "cancelled";
|
|
1818
|
+
}>;
|
|
1819
|
+
startedAt: z.ZodISODateTime;
|
|
1820
|
+
finishedAt: z.ZodOptional<z.ZodISODateTime>;
|
|
1821
|
+
output: z.ZodOptional<z.ZodString>;
|
|
1822
|
+
usage: z.ZodOptional<z.ZodObject<{
|
|
1823
|
+
inputTokens: z.ZodNumber;
|
|
1824
|
+
outputTokens: z.ZodNumber;
|
|
1825
|
+
}, z.core.$strict>>;
|
|
1826
|
+
contextManifestSha256: z.ZodString;
|
|
1827
|
+
errors: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
1828
|
+
attempt: z.ZodDefault<z.ZodNumber>;
|
|
1829
|
+
tools: z.ZodOptional<z.ZodObject<{
|
|
1830
|
+
offered: z.ZodArray<z.ZodString>;
|
|
1831
|
+
calls: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1832
|
+
round: z.ZodNumber;
|
|
1833
|
+
id: z.ZodOptional<z.ZodString>;
|
|
1834
|
+
name: z.ZodString;
|
|
1835
|
+
input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
|
|
1836
|
+
output: z.ZodString;
|
|
1837
|
+
tokens: z.ZodNumber;
|
|
1838
|
+
error: z.ZodOptional<z.ZodBoolean>;
|
|
1839
|
+
}, z.core.$strict>>>;
|
|
1840
|
+
stopped: z.ZodOptional<z.ZodString>;
|
|
1841
|
+
}, z.core.$strict>>;
|
|
1842
|
+
retrieval: z.ZodOptional<z.ZodObject<{
|
|
1843
|
+
expansion: z.ZodOptional<z.ZodObject<{
|
|
1844
|
+
run: z.ZodOptional<z.ZodString>;
|
|
1845
|
+
cached: z.ZodBoolean;
|
|
1846
|
+
terms: z.ZodArray<z.ZodString>;
|
|
1847
|
+
names: z.ZodArray<z.ZodObject<{
|
|
1848
|
+
name: z.ZodString;
|
|
1849
|
+
id: z.ZodOptional<z.ZodString>;
|
|
1850
|
+
new: z.ZodOptional<z.ZodBoolean>;
|
|
1851
|
+
quote: z.ZodString;
|
|
1852
|
+
}, z.core.$strict>>;
|
|
1853
|
+
dropped: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
1854
|
+
name: z.ZodString;
|
|
1855
|
+
why: z.ZodString;
|
|
1856
|
+
}, z.core.$strict>>>;
|
|
1857
|
+
}, z.core.$strict>>;
|
|
1858
|
+
rerank: z.ZodOptional<z.ZodObject<{
|
|
1859
|
+
run: z.ZodOptional<z.ZodString>;
|
|
1860
|
+
cached: z.ZodBoolean;
|
|
1861
|
+
shown: z.ZodNumber;
|
|
1862
|
+
order: z.ZodArray<z.ZodString>;
|
|
1863
|
+
dropped: z.ZodArray<z.ZodString>;
|
|
1864
|
+
used: z.ZodBoolean;
|
|
1865
|
+
}, z.core.$strict>>;
|
|
1866
|
+
meaning: z.ZodOptional<z.ZodString>;
|
|
1867
|
+
}, z.core.$strict>>;
|
|
1868
|
+
stepClass: z.ZodOptional<z.ZodEnum<{
|
|
1869
|
+
read: "read";
|
|
1870
|
+
draft: "draft";
|
|
1871
|
+
critic: "critic";
|
|
1872
|
+
knowledge: "knowledge";
|
|
1873
|
+
quick: "quick";
|
|
1874
|
+
}>>;
|
|
1875
|
+
model: z.ZodOptional<z.ZodString>;
|
|
1876
|
+
assistant: z.ZodOptional<z.ZodObject<{
|
|
1877
|
+
name: z.ZodString;
|
|
1878
|
+
version: z.ZodOptional<z.ZodString>;
|
|
1879
|
+
protocolVersion: z.ZodOptional<z.ZodNumber>;
|
|
1880
|
+
}, z.core.$strict>>;
|
|
1881
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
1882
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1883
|
+
name: z.ZodString;
|
|
1884
|
+
runId: z.ZodString;
|
|
1885
|
+
state: z.ZodOptional<z.ZodEnum<{
|
|
1886
|
+
failed: "failed";
|
|
1887
|
+
prepared: "prepared";
|
|
1888
|
+
waiting: "waiting";
|
|
1889
|
+
produced: "produced";
|
|
1890
|
+
validated: "validated";
|
|
1891
|
+
cancelled: "cancelled";
|
|
1892
|
+
}>>;
|
|
1893
|
+
}, z.core.$strict>>>;
|
|
1894
|
+
promptPath: z.ZodOptional<z.ZodString>;
|
|
1895
|
+
workspaceFile: z.ZodOptional<z.ZodString>;
|
|
1896
|
+
taskRun: z.ZodOptional<z.ZodObject<{
|
|
1897
|
+
task: z.ZodString;
|
|
1898
|
+
repo: z.ZodString;
|
|
1899
|
+
level: z.ZodString;
|
|
1900
|
+
state: z.ZodString;
|
|
1901
|
+
branch: z.ZodString;
|
|
1902
|
+
worktree: z.ZodString;
|
|
1903
|
+
notes: z.ZodArray<z.ZodString>;
|
|
1904
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
1905
|
+
log: z.ZodOptional<z.ZodString>;
|
|
1906
|
+
}, z.core.$strip>>;
|
|
1907
|
+
lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1908
|
+
next: z.ZodOptional<z.ZodString>;
|
|
1909
|
+
}, z.core.$strict>;
|
|
1910
|
+
/** 2.66.0 (UX review): the step prepared for the person's own assistant, and its run. */
|
|
1911
|
+
export declare const PreparedStepView: z.ZodObject<{
|
|
1912
|
+
runId: z.ZodOptional<z.ZodString>;
|
|
1913
|
+
lines: z.ZodArray<z.ZodString>;
|
|
1914
|
+
stillWaiting: z.ZodOptional<z.ZodBoolean>;
|
|
1915
|
+
}, z.core.$strip>;
|
|
1534
1916
|
export type StartStepRequest = z.infer<typeof StartStepRequest>;
|
|
1535
1917
|
export declare const RunList: z.ZodObject<{
|
|
1536
1918
|
runs: z.ZodArray<z.ZodObject<{
|
|
1537
|
-
schemaVersion: z.ZodLiteral<
|
|
1919
|
+
schemaVersion: z.ZodLiteral<6>;
|
|
1538
1920
|
runId: z.ZodString;
|
|
1539
1921
|
change: z.ZodString;
|
|
1540
1922
|
agent: z.ZodString;
|
|
@@ -1615,8 +1997,32 @@ export declare const RunList: z.ZodObject<{
|
|
|
1615
1997
|
version: z.ZodOptional<z.ZodString>;
|
|
1616
1998
|
protocolVersion: z.ZodOptional<z.ZodNumber>;
|
|
1617
1999
|
}, z.core.$strict>>;
|
|
2000
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
2001
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
2002
|
+
name: z.ZodString;
|
|
2003
|
+
runId: z.ZodString;
|
|
2004
|
+
state: z.ZodOptional<z.ZodEnum<{
|
|
2005
|
+
failed: "failed";
|
|
2006
|
+
prepared: "prepared";
|
|
2007
|
+
waiting: "waiting";
|
|
2008
|
+
produced: "produced";
|
|
2009
|
+
validated: "validated";
|
|
2010
|
+
cancelled: "cancelled";
|
|
2011
|
+
}>>;
|
|
2012
|
+
}, z.core.$strict>>>;
|
|
1618
2013
|
promptPath: z.ZodOptional<z.ZodString>;
|
|
1619
2014
|
workspaceFile: z.ZodOptional<z.ZodString>;
|
|
2015
|
+
taskRun: z.ZodOptional<z.ZodObject<{
|
|
2016
|
+
task: z.ZodString;
|
|
2017
|
+
repo: z.ZodString;
|
|
2018
|
+
level: z.ZodString;
|
|
2019
|
+
state: z.ZodString;
|
|
2020
|
+
branch: z.ZodString;
|
|
2021
|
+
worktree: z.ZodString;
|
|
2022
|
+
notes: z.ZodArray<z.ZodString>;
|
|
2023
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
2024
|
+
log: z.ZodOptional<z.ZodString>;
|
|
2025
|
+
}, z.core.$strip>>;
|
|
1620
2026
|
attempt: z.ZodNumber;
|
|
1621
2027
|
answered: z.ZodBoolean;
|
|
1622
2028
|
handedBack: z.ZodNumber;
|
|
@@ -1629,7 +2035,7 @@ export type RunList = z.infer<typeof RunList>;
|
|
|
1629
2035
|
/** ADR 0106: what one run was asked and answered, and what the checks handed back to it. */
|
|
1630
2036
|
export declare const RunTranscript: z.ZodObject<{
|
|
1631
2037
|
run: z.ZodObject<{
|
|
1632
|
-
schemaVersion: z.ZodLiteral<
|
|
2038
|
+
schemaVersion: z.ZodLiteral<6>;
|
|
1633
2039
|
runId: z.ZodString;
|
|
1634
2040
|
change: z.ZodString;
|
|
1635
2041
|
agent: z.ZodString;
|
|
@@ -1710,8 +2116,32 @@ export declare const RunTranscript: z.ZodObject<{
|
|
|
1710
2116
|
version: z.ZodOptional<z.ZodString>;
|
|
1711
2117
|
protocolVersion: z.ZodOptional<z.ZodNumber>;
|
|
1712
2118
|
}, z.core.$strict>>;
|
|
2119
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
2120
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
2121
|
+
name: z.ZodString;
|
|
2122
|
+
runId: z.ZodString;
|
|
2123
|
+
state: z.ZodOptional<z.ZodEnum<{
|
|
2124
|
+
failed: "failed";
|
|
2125
|
+
prepared: "prepared";
|
|
2126
|
+
waiting: "waiting";
|
|
2127
|
+
produced: "produced";
|
|
2128
|
+
validated: "validated";
|
|
2129
|
+
cancelled: "cancelled";
|
|
2130
|
+
}>>;
|
|
2131
|
+
}, z.core.$strict>>>;
|
|
1713
2132
|
promptPath: z.ZodOptional<z.ZodString>;
|
|
1714
2133
|
workspaceFile: z.ZodOptional<z.ZodString>;
|
|
2134
|
+
taskRun: z.ZodOptional<z.ZodObject<{
|
|
2135
|
+
task: z.ZodString;
|
|
2136
|
+
repo: z.ZodString;
|
|
2137
|
+
level: z.ZodString;
|
|
2138
|
+
state: z.ZodString;
|
|
2139
|
+
branch: z.ZodString;
|
|
2140
|
+
worktree: z.ZodString;
|
|
2141
|
+
notes: z.ZodArray<z.ZodString>;
|
|
2142
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
2143
|
+
log: z.ZodOptional<z.ZodString>;
|
|
2144
|
+
}, z.core.$strip>>;
|
|
1715
2145
|
attempt: z.ZodNumber;
|
|
1716
2146
|
answered: z.ZodBoolean;
|
|
1717
2147
|
handedBack: z.ZodNumber;
|
|
@@ -1780,8 +2210,8 @@ export declare const HistorySurface: z.ZodEnum<{
|
|
|
1780
2210
|
}>;
|
|
1781
2211
|
export type HistorySurface = z.infer<typeof HistorySurface>;
|
|
1782
2212
|
export declare const HistoryKind: z.ZodEnum<{
|
|
1783
|
-
prompt: "prompt";
|
|
1784
2213
|
response: "response";
|
|
2214
|
+
prompt: "prompt";
|
|
1785
2215
|
}>;
|
|
1786
2216
|
export type HistoryKind = z.infer<typeof HistoryKind>;
|
|
1787
2217
|
/** ADR 0110: one record's text is kept up to this many bytes; a longer one is cut and marked. */
|
|
@@ -1797,8 +2227,8 @@ export declare const HistoryRecord: z.ZodObject<{
|
|
|
1797
2227
|
}>;
|
|
1798
2228
|
session: z.ZodString;
|
|
1799
2229
|
kind: z.ZodEnum<{
|
|
1800
|
-
prompt: "prompt";
|
|
1801
2230
|
response: "response";
|
|
2231
|
+
prompt: "prompt";
|
|
1802
2232
|
}>;
|
|
1803
2233
|
text: z.ZodString;
|
|
1804
2234
|
size: z.ZodNumber;
|
|
@@ -1828,8 +2258,8 @@ export declare const HistoryTurn: z.ZodObject<{
|
|
|
1828
2258
|
}>;
|
|
1829
2259
|
session: z.ZodString;
|
|
1830
2260
|
kind: z.ZodEnum<{
|
|
1831
|
-
prompt: "prompt";
|
|
1832
2261
|
response: "response";
|
|
2262
|
+
prompt: "prompt";
|
|
1833
2263
|
}>;
|
|
1834
2264
|
text: z.ZodString;
|
|
1835
2265
|
size: z.ZodNumber;
|
|
@@ -1848,8 +2278,8 @@ export declare const HistoryTurn: z.ZodObject<{
|
|
|
1848
2278
|
}>;
|
|
1849
2279
|
session: z.ZodString;
|
|
1850
2280
|
kind: z.ZodEnum<{
|
|
1851
|
-
prompt: "prompt";
|
|
1852
2281
|
response: "response";
|
|
2282
|
+
prompt: "prompt";
|
|
1853
2283
|
}>;
|
|
1854
2284
|
text: z.ZodString;
|
|
1855
2285
|
size: z.ZodNumber;
|
|
@@ -1889,8 +2319,8 @@ export declare const HistoryList: z.ZodObject<{
|
|
|
1889
2319
|
}>;
|
|
1890
2320
|
session: z.ZodString;
|
|
1891
2321
|
kind: z.ZodEnum<{
|
|
1892
|
-
prompt: "prompt";
|
|
1893
2322
|
response: "response";
|
|
2323
|
+
prompt: "prompt";
|
|
1894
2324
|
}>;
|
|
1895
2325
|
text: z.ZodString;
|
|
1896
2326
|
size: z.ZodNumber;
|
|
@@ -1909,8 +2339,8 @@ export declare const HistoryList: z.ZodObject<{
|
|
|
1909
2339
|
}>;
|
|
1910
2340
|
session: z.ZodString;
|
|
1911
2341
|
kind: z.ZodEnum<{
|
|
1912
|
-
prompt: "prompt";
|
|
1913
2342
|
response: "response";
|
|
2343
|
+
prompt: "prompt";
|
|
1914
2344
|
}>;
|
|
1915
2345
|
text: z.ZodString;
|
|
1916
2346
|
size: z.ZodNumber;
|
|
@@ -1941,8 +2371,8 @@ export declare const HistoryEntry: z.ZodObject<{
|
|
|
1941
2371
|
}>;
|
|
1942
2372
|
session: z.ZodString;
|
|
1943
2373
|
kind: z.ZodEnum<{
|
|
1944
|
-
prompt: "prompt";
|
|
1945
2374
|
response: "response";
|
|
2375
|
+
prompt: "prompt";
|
|
1946
2376
|
}>;
|
|
1947
2377
|
text: z.ZodString;
|
|
1948
2378
|
size: z.ZodNumber;
|
|
@@ -1961,8 +2391,8 @@ export declare const HistoryEntry: z.ZodObject<{
|
|
|
1961
2391
|
}>;
|
|
1962
2392
|
session: z.ZodString;
|
|
1963
2393
|
kind: z.ZodEnum<{
|
|
1964
|
-
prompt: "prompt";
|
|
1965
2394
|
response: "response";
|
|
2395
|
+
prompt: "prompt";
|
|
1966
2396
|
}>;
|
|
1967
2397
|
text: z.ZodString;
|
|
1968
2398
|
size: z.ZodNumber;
|
|
@@ -2044,6 +2474,7 @@ export declare const EditRepoDescriptionRequest: z.ZodObject<{
|
|
|
2044
2474
|
text: z.ZodOptional<z.ZodString>;
|
|
2045
2475
|
accept: z.ZodOptional<z.ZodBoolean>;
|
|
2046
2476
|
reject: z.ZodOptional<z.ZodBoolean>;
|
|
2477
|
+
was: z.ZodOptional<z.ZodString>;
|
|
2047
2478
|
}, z.core.$strip>;
|
|
2048
2479
|
export declare const OnboardingRepo: z.ZodObject<{
|
|
2049
2480
|
id: z.ZodString;
|
|
@@ -2310,6 +2741,17 @@ export declare const TrustRepo: z.ZodObject<{
|
|
|
2310
2741
|
low: z.ZodNullable<z.ZodNumber>;
|
|
2311
2742
|
high: z.ZodNullable<z.ZodNumber>;
|
|
2312
2743
|
}, z.core.$strip>;
|
|
2744
|
+
ai: z.ZodOptional<z.ZodObject<{
|
|
2745
|
+
drawn: z.ZodNumber;
|
|
2746
|
+
right: z.ZodNumber;
|
|
2747
|
+
wrong: z.ZodNumber;
|
|
2748
|
+
unsure: z.ZodNumber;
|
|
2749
|
+
open: z.ZodNumber;
|
|
2750
|
+
gone: z.ZodNumber;
|
|
2751
|
+
precision: z.ZodNullable<z.ZodNumber>;
|
|
2752
|
+
low: z.ZodNullable<z.ZodNumber>;
|
|
2753
|
+
high: z.ZodNullable<z.ZodNumber>;
|
|
2754
|
+
}, z.core.$strip>>;
|
|
2313
2755
|
}, z.core.$strip>>;
|
|
2314
2756
|
}, z.core.$strip>;
|
|
2315
2757
|
/** 2.47.0 (ADR 0164): the contract check's counts. */
|
|
@@ -2453,6 +2895,17 @@ export declare const TrustView: z.ZodObject<{
|
|
|
2453
2895
|
low: z.ZodNullable<z.ZodNumber>;
|
|
2454
2896
|
high: z.ZodNullable<z.ZodNumber>;
|
|
2455
2897
|
}, z.core.$strip>;
|
|
2898
|
+
ai: z.ZodOptional<z.ZodObject<{
|
|
2899
|
+
drawn: z.ZodNumber;
|
|
2900
|
+
right: z.ZodNumber;
|
|
2901
|
+
wrong: z.ZodNumber;
|
|
2902
|
+
unsure: z.ZodNumber;
|
|
2903
|
+
open: z.ZodNumber;
|
|
2904
|
+
gone: z.ZodNumber;
|
|
2905
|
+
precision: z.ZodNullable<z.ZodNumber>;
|
|
2906
|
+
low: z.ZodNullable<z.ZodNumber>;
|
|
2907
|
+
high: z.ZodNullable<z.ZodNumber>;
|
|
2908
|
+
}, z.core.$strip>>;
|
|
2456
2909
|
}, z.core.$strip>>;
|
|
2457
2910
|
}, z.core.$strip>>;
|
|
2458
2911
|
contracts: z.ZodOptional<z.ZodObject<{
|
|
@@ -2857,11 +3310,12 @@ export declare const FactCiteView: z.ZodObject<{
|
|
|
2857
3310
|
reader: "reader";
|
|
2858
3311
|
}>;
|
|
2859
3312
|
correction: z.ZodOptional<z.ZodObject<{
|
|
2860
|
-
schemaVersion: z.ZodLiteral<1>;
|
|
3313
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
2861
3314
|
fact: z.ZodString;
|
|
2862
3315
|
target: z.ZodObject<{
|
|
2863
3316
|
kind: z.ZodEnum<{
|
|
2864
3317
|
config: "config";
|
|
3318
|
+
component: "component";
|
|
2865
3319
|
field: "field";
|
|
2866
3320
|
term: "term";
|
|
2867
3321
|
framework: "framework";
|
|
@@ -2876,14 +3330,41 @@ export declare const FactCiteView: z.ZodObject<{
|
|
|
2876
3330
|
value: z.ZodString;
|
|
2877
3331
|
}, z.core.$strict>;
|
|
2878
3332
|
action: z.ZodEnum<{
|
|
3333
|
+
link: "link";
|
|
2879
3334
|
wrong: "wrong";
|
|
2880
3335
|
edit: "edit";
|
|
3336
|
+
unlink: "unlink";
|
|
2881
3337
|
}>;
|
|
3338
|
+
link: z.ZodOptional<z.ZodObject<{
|
|
3339
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
3340
|
+
system: z.ZodOptional<z.ZodString>;
|
|
3341
|
+
entry: z.ZodOptional<z.ZodString>;
|
|
3342
|
+
method: z.ZodOptional<z.ZodString>;
|
|
3343
|
+
path: z.ZodString;
|
|
3344
|
+
}, z.core.$strict>>;
|
|
2882
3345
|
set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
2883
3346
|
line: z.ZodOptional<z.ZodNumber>;
|
|
2884
3347
|
reason: z.ZodOptional<z.ZodString>;
|
|
2885
3348
|
by: z.ZodString;
|
|
2886
3349
|
at: z.ZodISODateTime;
|
|
3350
|
+
ai: z.ZodOptional<z.ZodObject<{
|
|
3351
|
+
runtime: z.ZodEnum<{
|
|
3352
|
+
"hand-off": "hand-off";
|
|
3353
|
+
"copilot-acp": "copilot-acp";
|
|
3354
|
+
}>;
|
|
3355
|
+
run: z.ZodString;
|
|
3356
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
3357
|
+
confident: "confident";
|
|
3358
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
3359
|
+
"person-rule": "person-rule";
|
|
3360
|
+
}>>;
|
|
3361
|
+
}, z.core.$strict>>;
|
|
3362
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
3363
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
3364
|
+
from: z.ZodString;
|
|
3365
|
+
match: z.ZodString;
|
|
3366
|
+
}, z.core.$strict>>;
|
|
3367
|
+
match: z.ZodOptional<z.ZodString>;
|
|
2887
3368
|
}, z.core.$strict>>;
|
|
2888
3369
|
}, z.core.$strip>;
|
|
2889
3370
|
export declare const RepoFactsView: z.ZodObject<{
|
|
@@ -2921,11 +3402,12 @@ export declare const RepoFactsView: z.ZodObject<{
|
|
|
2921
3402
|
reader: "reader";
|
|
2922
3403
|
}>;
|
|
2923
3404
|
correction: z.ZodOptional<z.ZodObject<{
|
|
2924
|
-
schemaVersion: z.ZodLiteral<1>;
|
|
3405
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
2925
3406
|
fact: z.ZodString;
|
|
2926
3407
|
target: z.ZodObject<{
|
|
2927
3408
|
kind: z.ZodEnum<{
|
|
2928
3409
|
config: "config";
|
|
3410
|
+
component: "component";
|
|
2929
3411
|
field: "field";
|
|
2930
3412
|
term: "term";
|
|
2931
3413
|
framework: "framework";
|
|
@@ -2940,14 +3422,41 @@ export declare const RepoFactsView: z.ZodObject<{
|
|
|
2940
3422
|
value: z.ZodString;
|
|
2941
3423
|
}, z.core.$strict>;
|
|
2942
3424
|
action: z.ZodEnum<{
|
|
3425
|
+
link: "link";
|
|
2943
3426
|
wrong: "wrong";
|
|
2944
3427
|
edit: "edit";
|
|
3428
|
+
unlink: "unlink";
|
|
2945
3429
|
}>;
|
|
3430
|
+
link: z.ZodOptional<z.ZodObject<{
|
|
3431
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
3432
|
+
system: z.ZodOptional<z.ZodString>;
|
|
3433
|
+
entry: z.ZodOptional<z.ZodString>;
|
|
3434
|
+
method: z.ZodOptional<z.ZodString>;
|
|
3435
|
+
path: z.ZodString;
|
|
3436
|
+
}, z.core.$strict>>;
|
|
2946
3437
|
set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
2947
3438
|
line: z.ZodOptional<z.ZodNumber>;
|
|
2948
3439
|
reason: z.ZodOptional<z.ZodString>;
|
|
2949
3440
|
by: z.ZodString;
|
|
2950
3441
|
at: z.ZodISODateTime;
|
|
3442
|
+
ai: z.ZodOptional<z.ZodObject<{
|
|
3443
|
+
runtime: z.ZodEnum<{
|
|
3444
|
+
"hand-off": "hand-off";
|
|
3445
|
+
"copilot-acp": "copilot-acp";
|
|
3446
|
+
}>;
|
|
3447
|
+
run: z.ZodString;
|
|
3448
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
3449
|
+
confident: "confident";
|
|
3450
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
3451
|
+
"person-rule": "person-rule";
|
|
3452
|
+
}>>;
|
|
3453
|
+
}, z.core.$strict>>;
|
|
3454
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
3455
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
3456
|
+
from: z.ZodString;
|
|
3457
|
+
match: z.ZodString;
|
|
3458
|
+
}, z.core.$strict>>;
|
|
3459
|
+
match: z.ZodOptional<z.ZodString>;
|
|
2951
3460
|
}, z.core.$strict>>;
|
|
2952
3461
|
}, z.core.$strip>>;
|
|
2953
3462
|
corrections: z.ZodObject<{
|
|
@@ -2979,11 +3488,12 @@ export declare const FactCorrectionRequest: z.ZodObject<{
|
|
|
2979
3488
|
}, z.core.$strict>;
|
|
2980
3489
|
export declare const FactCorrectionResult: z.ZodObject<{
|
|
2981
3490
|
correction: z.ZodObject<{
|
|
2982
|
-
schemaVersion: z.ZodLiteral<1>;
|
|
3491
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
2983
3492
|
fact: z.ZodString;
|
|
2984
3493
|
target: z.ZodObject<{
|
|
2985
3494
|
kind: z.ZodEnum<{
|
|
2986
3495
|
config: "config";
|
|
3496
|
+
component: "component";
|
|
2987
3497
|
field: "field";
|
|
2988
3498
|
term: "term";
|
|
2989
3499
|
framework: "framework";
|
|
@@ -2998,14 +3508,41 @@ export declare const FactCorrectionResult: z.ZodObject<{
|
|
|
2998
3508
|
value: z.ZodString;
|
|
2999
3509
|
}, z.core.$strict>;
|
|
3000
3510
|
action: z.ZodEnum<{
|
|
3511
|
+
link: "link";
|
|
3001
3512
|
wrong: "wrong";
|
|
3002
3513
|
edit: "edit";
|
|
3514
|
+
unlink: "unlink";
|
|
3003
3515
|
}>;
|
|
3516
|
+
link: z.ZodOptional<z.ZodObject<{
|
|
3517
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
3518
|
+
system: z.ZodOptional<z.ZodString>;
|
|
3519
|
+
entry: z.ZodOptional<z.ZodString>;
|
|
3520
|
+
method: z.ZodOptional<z.ZodString>;
|
|
3521
|
+
path: z.ZodString;
|
|
3522
|
+
}, z.core.$strict>>;
|
|
3004
3523
|
set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
3005
3524
|
line: z.ZodOptional<z.ZodNumber>;
|
|
3006
3525
|
reason: z.ZodOptional<z.ZodString>;
|
|
3007
3526
|
by: z.ZodString;
|
|
3008
3527
|
at: z.ZodISODateTime;
|
|
3528
|
+
ai: z.ZodOptional<z.ZodObject<{
|
|
3529
|
+
runtime: z.ZodEnum<{
|
|
3530
|
+
"hand-off": "hand-off";
|
|
3531
|
+
"copilot-acp": "copilot-acp";
|
|
3532
|
+
}>;
|
|
3533
|
+
run: z.ZodString;
|
|
3534
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
3535
|
+
confident: "confident";
|
|
3536
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
3537
|
+
"person-rule": "person-rule";
|
|
3538
|
+
}>>;
|
|
3539
|
+
}, z.core.$strict>>;
|
|
3540
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
3541
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
3542
|
+
from: z.ZodString;
|
|
3543
|
+
match: z.ZodString;
|
|
3544
|
+
}, z.core.$strict>>;
|
|
3545
|
+
match: z.ZodOptional<z.ZodString>;
|
|
3009
3546
|
}, z.core.$strict>;
|
|
3010
3547
|
file: z.ZodString;
|
|
3011
3548
|
commit: z.ZodString;
|
|
@@ -3177,6 +3714,7 @@ export type PreviewLinkViewT = z.infer<typeof PreviewLinkView>;
|
|
|
3177
3714
|
export declare const AuditItemView: z.ZodObject<{
|
|
3178
3715
|
id: z.ZodString;
|
|
3179
3716
|
kind: z.ZodEnum<{
|
|
3717
|
+
ai: "ai";
|
|
3180
3718
|
link: "link";
|
|
3181
3719
|
fact: "fact";
|
|
3182
3720
|
}>;
|
|
@@ -3186,10 +3724,12 @@ export declare const AuditItemView: z.ZodObject<{
|
|
|
3186
3724
|
fact: z.ZodOptional<z.ZodString>;
|
|
3187
3725
|
value: z.ZodOptional<z.ZodString>;
|
|
3188
3726
|
to: z.ZodOptional<z.ZodString>;
|
|
3727
|
+
decided: z.ZodOptional<z.ZodString>;
|
|
3728
|
+
run: z.ZodOptional<z.ZodString>;
|
|
3189
3729
|
answer: z.ZodOptional<z.ZodEnum<{
|
|
3190
|
-
unsure: "unsure";
|
|
3191
|
-
wrong: "wrong";
|
|
3192
3730
|
right: "right";
|
|
3731
|
+
wrong: "wrong";
|
|
3732
|
+
unsure: "unsure";
|
|
3193
3733
|
}>>;
|
|
3194
3734
|
note: z.ZodOptional<z.ZodString>;
|
|
3195
3735
|
by: z.ZodOptional<z.ZodString>;
|
|
@@ -3208,6 +3748,7 @@ export declare const AuditSampleView: z.ZodObject<{
|
|
|
3208
3748
|
items: z.ZodArray<z.ZodObject<{
|
|
3209
3749
|
id: z.ZodString;
|
|
3210
3750
|
kind: z.ZodEnum<{
|
|
3751
|
+
ai: "ai";
|
|
3211
3752
|
link: "link";
|
|
3212
3753
|
fact: "fact";
|
|
3213
3754
|
}>;
|
|
@@ -3217,10 +3758,12 @@ export declare const AuditSampleView: z.ZodObject<{
|
|
|
3217
3758
|
fact: z.ZodOptional<z.ZodString>;
|
|
3218
3759
|
value: z.ZodOptional<z.ZodString>;
|
|
3219
3760
|
to: z.ZodOptional<z.ZodString>;
|
|
3761
|
+
decided: z.ZodOptional<z.ZodString>;
|
|
3762
|
+
run: z.ZodOptional<z.ZodString>;
|
|
3220
3763
|
answer: z.ZodOptional<z.ZodEnum<{
|
|
3221
|
-
unsure: "unsure";
|
|
3222
|
-
wrong: "wrong";
|
|
3223
3764
|
right: "right";
|
|
3765
|
+
wrong: "wrong";
|
|
3766
|
+
unsure: "unsure";
|
|
3224
3767
|
}>>;
|
|
3225
3768
|
note: z.ZodOptional<z.ZodString>;
|
|
3226
3769
|
by: z.ZodOptional<z.ZodString>;
|
|
@@ -3269,9 +3812,9 @@ export declare const AuditAnswerRequest: z.ZodObject<{
|
|
|
3269
3812
|
answers: z.ZodArray<z.ZodObject<{
|
|
3270
3813
|
id: z.ZodString;
|
|
3271
3814
|
answer: z.ZodEnum<{
|
|
3272
|
-
unsure: "unsure";
|
|
3273
|
-
wrong: "wrong";
|
|
3274
3815
|
right: "right";
|
|
3816
|
+
wrong: "wrong";
|
|
3817
|
+
unsure: "unsure";
|
|
3275
3818
|
}>;
|
|
3276
3819
|
note: z.ZodOptional<z.ZodString>;
|
|
3277
3820
|
}, z.core.$strict>>;
|
|
@@ -3283,6 +3826,7 @@ export declare const AuditAnswerResult: z.ZodObject<{
|
|
|
3283
3826
|
items: z.ZodArray<z.ZodObject<{
|
|
3284
3827
|
id: z.ZodString;
|
|
3285
3828
|
kind: z.ZodEnum<{
|
|
3829
|
+
ai: "ai";
|
|
3286
3830
|
link: "link";
|
|
3287
3831
|
fact: "fact";
|
|
3288
3832
|
}>;
|
|
@@ -3292,10 +3836,12 @@ export declare const AuditAnswerResult: z.ZodObject<{
|
|
|
3292
3836
|
fact: z.ZodOptional<z.ZodString>;
|
|
3293
3837
|
value: z.ZodOptional<z.ZodString>;
|
|
3294
3838
|
to: z.ZodOptional<z.ZodString>;
|
|
3839
|
+
decided: z.ZodOptional<z.ZodString>;
|
|
3840
|
+
run: z.ZodOptional<z.ZodString>;
|
|
3295
3841
|
answer: z.ZodOptional<z.ZodEnum<{
|
|
3296
|
-
unsure: "unsure";
|
|
3297
|
-
wrong: "wrong";
|
|
3298
3842
|
right: "right";
|
|
3843
|
+
wrong: "wrong";
|
|
3844
|
+
unsure: "unsure";
|
|
3299
3845
|
}>>;
|
|
3300
3846
|
note: z.ZodOptional<z.ZodString>;
|
|
3301
3847
|
by: z.ZodOptional<z.ZodString>;
|
|
@@ -4030,6 +4576,7 @@ export declare const StageFindingView: z.ZodObject<{
|
|
|
4030
4576
|
org: "org";
|
|
4031
4577
|
}>;
|
|
4032
4578
|
lens: z.ZodEnum<{
|
|
4579
|
+
release: "release";
|
|
4033
4580
|
true: "true";
|
|
4034
4581
|
complete: "complete";
|
|
4035
4582
|
safe: "safe";
|
|
@@ -4040,7 +4587,6 @@ export declare const StageFindingView: z.ZodObject<{
|
|
|
4040
4587
|
ux: "ux";
|
|
4041
4588
|
delivery: "delivery";
|
|
4042
4589
|
"code-and-test": "code-and-test";
|
|
4043
|
-
release: "release";
|
|
4044
4590
|
}>;
|
|
4045
4591
|
severity: z.ZodEnum<{
|
|
4046
4592
|
blocking: "blocking";
|
|
@@ -4178,6 +4724,7 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4178
4724
|
org: "org";
|
|
4179
4725
|
}>;
|
|
4180
4726
|
lens: z.ZodEnum<{
|
|
4727
|
+
release: "release";
|
|
4181
4728
|
true: "true";
|
|
4182
4729
|
complete: "complete";
|
|
4183
4730
|
safe: "safe";
|
|
@@ -4188,7 +4735,6 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4188
4735
|
ux: "ux";
|
|
4189
4736
|
delivery: "delivery";
|
|
4190
4737
|
"code-and-test": "code-and-test";
|
|
4191
|
-
release: "release";
|
|
4192
4738
|
}>;
|
|
4193
4739
|
severity: z.ZodEnum<{
|
|
4194
4740
|
blocking: "blocking";
|
|
@@ -4294,7 +4840,7 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4294
4840
|
}, z.core.$strip>>;
|
|
4295
4841
|
}, z.core.$strip>>;
|
|
4296
4842
|
questions: z.ZodArray<z.ZodObject<{
|
|
4297
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
|
|
4843
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
4298
4844
|
id: z.ZodString;
|
|
4299
4845
|
askedBy: z.ZodObject<{
|
|
4300
4846
|
step: z.ZodString;
|
|
@@ -4324,6 +4870,19 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4324
4870
|
}>;
|
|
4325
4871
|
id: z.ZodString;
|
|
4326
4872
|
}, z.core.$strict>;
|
|
4873
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
4874
|
+
product: "product";
|
|
4875
|
+
architecture: "architecture";
|
|
4876
|
+
delivery: "delivery";
|
|
4877
|
+
analysis: "analysis";
|
|
4878
|
+
}>>;
|
|
4879
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
4880
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
4881
|
+
change: z.ZodString;
|
|
4882
|
+
gate: z.ZodString;
|
|
4883
|
+
round: z.ZodNumber;
|
|
4884
|
+
id: z.ZodString;
|
|
4885
|
+
}, z.core.$strict>>;
|
|
4327
4886
|
state: z.ZodEnum<{
|
|
4328
4887
|
retired: "retired";
|
|
4329
4888
|
open: "open";
|
|
@@ -4333,7 +4892,19 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4333
4892
|
answer: z.ZodOptional<z.ZodObject<{
|
|
4334
4893
|
option: z.ZodOptional<z.ZodNumber>;
|
|
4335
4894
|
text: z.ZodOptional<z.ZodString>;
|
|
4336
|
-
by: z.ZodString
|
|
4895
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
4896
|
+
kind: z.ZodLiteral<"ai">;
|
|
4897
|
+
runtime: z.ZodEnum<{
|
|
4898
|
+
"hand-off": "hand-off";
|
|
4899
|
+
"copilot-acp": "copilot-acp";
|
|
4900
|
+
}>;
|
|
4901
|
+
run: z.ZodString;
|
|
4902
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
4903
|
+
confident: "confident";
|
|
4904
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
4905
|
+
"person-rule": "person-rule";
|
|
4906
|
+
}>>;
|
|
4907
|
+
}, z.core.$strict>]>;
|
|
4337
4908
|
at: z.ZodISODateTime;
|
|
4338
4909
|
scope: z.ZodObject<{
|
|
4339
4910
|
level: z.ZodEnum<{
|
|
@@ -4354,6 +4925,11 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4354
4925
|
quote: z.ZodString;
|
|
4355
4926
|
}, z.core.$strict>>;
|
|
4356
4927
|
}, z.core.$strict>>;
|
|
4928
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
4929
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
4930
|
+
from: z.ZodString;
|
|
4931
|
+
match: z.ZodString;
|
|
4932
|
+
}, z.core.$strict>>;
|
|
4357
4933
|
}, z.core.$strict>>;
|
|
4358
4934
|
retired: z.ZodOptional<z.ZodObject<{
|
|
4359
4935
|
at: z.ZodISODateTime;
|
|
@@ -4366,7 +4942,19 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4366
4942
|
answer: z.ZodObject<{
|
|
4367
4943
|
option: z.ZodOptional<z.ZodNumber>;
|
|
4368
4944
|
text: z.ZodOptional<z.ZodString>;
|
|
4369
|
-
by: z.ZodString
|
|
4945
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
4946
|
+
kind: z.ZodLiteral<"ai">;
|
|
4947
|
+
runtime: z.ZodEnum<{
|
|
4948
|
+
"hand-off": "hand-off";
|
|
4949
|
+
"copilot-acp": "copilot-acp";
|
|
4950
|
+
}>;
|
|
4951
|
+
run: z.ZodString;
|
|
4952
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
4953
|
+
confident: "confident";
|
|
4954
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
4955
|
+
"person-rule": "person-rule";
|
|
4956
|
+
}>>;
|
|
4957
|
+
}, z.core.$strict>]>;
|
|
4370
4958
|
at: z.ZodISODateTime;
|
|
4371
4959
|
scope: z.ZodObject<{
|
|
4372
4960
|
level: z.ZodEnum<{
|
|
@@ -4387,13 +4975,18 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4387
4975
|
quote: z.ZodString;
|
|
4388
4976
|
}, z.core.$strict>>;
|
|
4389
4977
|
}, z.core.$strict>>;
|
|
4978
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
4979
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
4980
|
+
from: z.ZodString;
|
|
4981
|
+
match: z.ZodString;
|
|
4982
|
+
}, z.core.$strict>>;
|
|
4390
4983
|
}, z.core.$strict>;
|
|
4391
4984
|
}, z.core.$strict>>;
|
|
4392
4985
|
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
4393
4986
|
id: z.ZodString;
|
|
4394
4987
|
verdict: z.ZodEnum<{
|
|
4395
|
-
narrower: "narrower";
|
|
4396
4988
|
unsure: "unsure";
|
|
4989
|
+
narrower: "narrower";
|
|
4397
4990
|
}>;
|
|
4398
4991
|
judgment: z.ZodOptional<z.ZodString>;
|
|
4399
4992
|
}, z.core.$strict>>>;
|
|
@@ -4407,6 +5000,34 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4407
5000
|
message: z.ZodString;
|
|
4408
5001
|
}, z.core.$strip>>;
|
|
4409
5002
|
}, z.core.$strip>;
|
|
5003
|
+
/**
|
|
5004
|
+
* 2.77.0 (eighth UX walk): the feature stage's placement. feature.md is drawn from feature.yaml
|
|
5005
|
+
* (the source a person edits; the stage's next run reads it), so the page shows the one and
|
|
5006
|
+
* edits the other. `drafted` says who wrote feature.yaml last: the AI at the feature stage, or a
|
|
5007
|
+
* person who saved it here (or edited its first line away).
|
|
5008
|
+
*/
|
|
5009
|
+
export declare const PlacementView: z.ZodObject<{
|
|
5010
|
+
change: z.ZodString;
|
|
5011
|
+
present: z.ZodBoolean;
|
|
5012
|
+
file: z.ZodString;
|
|
5013
|
+
content: z.ZodString;
|
|
5014
|
+
source: z.ZodString;
|
|
5015
|
+
sourceContent: z.ZodString;
|
|
5016
|
+
sha256: z.ZodString;
|
|
5017
|
+
drafted: z.ZodOptional<z.ZodObject<{
|
|
5018
|
+
by: z.ZodEnum<{
|
|
5019
|
+
ai: "ai";
|
|
5020
|
+
person: "person";
|
|
5021
|
+
}>;
|
|
5022
|
+
who: z.ZodOptional<z.ZodString>;
|
|
5023
|
+
at: z.ZodOptional<z.ZodString>;
|
|
5024
|
+
}, z.core.$strip>>;
|
|
5025
|
+
}, z.core.$strip>;
|
|
5026
|
+
export type PlacementViewT = z.infer<typeof PlacementView>;
|
|
5027
|
+
export declare const SavePlacementRequest: z.ZodObject<{
|
|
5028
|
+
content: z.ZodString;
|
|
5029
|
+
baseSha256: z.ZodString;
|
|
5030
|
+
}, z.core.$strict>;
|
|
4410
5031
|
export declare const StageCommentRequest: z.ZodObject<{
|
|
4411
5032
|
finding: z.ZodString;
|
|
4412
5033
|
gate: z.ZodOptional<z.ZodString>;
|
|
@@ -4430,6 +5051,218 @@ export declare const StageCommentResult: z.ZodObject<{
|
|
|
4430
5051
|
export type StageReviewViewT = z.infer<typeof StageReviewView>;
|
|
4431
5052
|
export type StageFindingViewT = z.infer<typeof StageFindingView>;
|
|
4432
5053
|
export type StageCommentResultT = z.infer<typeof StageCommentResult>;
|
|
5054
|
+
/**
|
|
5055
|
+
* 2.80.0 (ADR 0181, stage drafts): AI decides first, a person corrects, and the AI corrects the
|
|
5056
|
+
* rest like it. A page's stage drafts (Feature design: feature.md and proposal.md; Architecture:
|
|
5057
|
+
* the target flows, design.md and data.md; Stories: the stories and the specs; Tasks: tasks.md),
|
|
5058
|
+
* each with who wrote it last (`drafted`: the AI with its stage and run, from
|
|
5059
|
+
* `stage/drafted.yaml`, until a person saves it) and the items a person can correct. A
|
|
5060
|
+
* correction (`stage/corrections.yaml`) is read by the stage's next run as the person's word in
|
|
5061
|
+
* its brief; with `scope: similar` the run applies it to every item like it. After the run it is
|
|
5062
|
+
* `applied` when the draft changed its item (else `read`), and `touched` lists the other items
|
|
5063
|
+
* the draft changed for it. Kept on file either way.
|
|
5064
|
+
*/
|
|
5065
|
+
export declare const DRAFT_PAGES: readonly ["feature", "architecture", "stories", "tasks"];
|
|
5066
|
+
export declare const DraftPage: z.ZodEnum<{
|
|
5067
|
+
architecture: "architecture";
|
|
5068
|
+
stories: "stories";
|
|
5069
|
+
tasks: "tasks";
|
|
5070
|
+
feature: "feature";
|
|
5071
|
+
}>;
|
|
5072
|
+
export declare const DraftProvenance: z.ZodObject<{
|
|
5073
|
+
by: z.ZodEnum<{
|
|
5074
|
+
ai: "ai";
|
|
5075
|
+
person: "person";
|
|
5076
|
+
}>;
|
|
5077
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
5078
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5079
|
+
who: z.ZodOptional<z.ZodString>;
|
|
5080
|
+
at: z.ZodOptional<z.ZodString>;
|
|
5081
|
+
}, z.core.$strip>;
|
|
5082
|
+
export declare const DraftItemView: z.ZodObject<{
|
|
5083
|
+
id: z.ZodString;
|
|
5084
|
+
label: z.ZodString;
|
|
5085
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5086
|
+
}, z.core.$strip>;
|
|
5087
|
+
export declare const DraftFileView: z.ZodObject<{
|
|
5088
|
+
file: z.ZodString;
|
|
5089
|
+
path: z.ZodString;
|
|
5090
|
+
stage: z.ZodString;
|
|
5091
|
+
drafted: z.ZodOptional<z.ZodObject<{
|
|
5092
|
+
by: z.ZodEnum<{
|
|
5093
|
+
ai: "ai";
|
|
5094
|
+
person: "person";
|
|
5095
|
+
}>;
|
|
5096
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
5097
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5098
|
+
who: z.ZodOptional<z.ZodString>;
|
|
5099
|
+
at: z.ZodOptional<z.ZodString>;
|
|
5100
|
+
}, z.core.$strip>>;
|
|
5101
|
+
items: z.ZodArray<z.ZodObject<{
|
|
5102
|
+
id: z.ZodString;
|
|
5103
|
+
label: z.ZodString;
|
|
5104
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5105
|
+
}, z.core.$strip>>;
|
|
5106
|
+
}, z.core.$strip>;
|
|
5107
|
+
export declare const CorrectionView: z.ZodObject<{
|
|
5108
|
+
id: z.ZodString;
|
|
5109
|
+
stage: z.ZodString;
|
|
5110
|
+
file: z.ZodString;
|
|
5111
|
+
item: z.ZodOptional<z.ZodString>;
|
|
5112
|
+
label: z.ZodString;
|
|
5113
|
+
text: z.ZodString;
|
|
5114
|
+
scope: z.ZodEnum<{
|
|
5115
|
+
one: "one";
|
|
5116
|
+
similar: "similar";
|
|
5117
|
+
}>;
|
|
5118
|
+
like: z.ZodOptional<z.ZodString>;
|
|
5119
|
+
by: z.ZodString;
|
|
5120
|
+
at: z.ZodString;
|
|
5121
|
+
state: z.ZodEnum<{
|
|
5122
|
+
read: "read";
|
|
5123
|
+
applied: "applied";
|
|
5124
|
+
waiting: "waiting";
|
|
5125
|
+
}>;
|
|
5126
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5127
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
5128
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
5129
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5130
|
+
}, z.core.$strip>;
|
|
5131
|
+
export declare const StageDraftsView: z.ZodObject<{
|
|
5132
|
+
change: z.ZodString;
|
|
5133
|
+
page: z.ZodEnum<{
|
|
5134
|
+
architecture: "architecture";
|
|
5135
|
+
stories: "stories";
|
|
5136
|
+
tasks: "tasks";
|
|
5137
|
+
feature: "feature";
|
|
5138
|
+
}>;
|
|
5139
|
+
files: z.ZodArray<z.ZodObject<{
|
|
5140
|
+
file: z.ZodString;
|
|
5141
|
+
path: z.ZodString;
|
|
5142
|
+
stage: z.ZodString;
|
|
5143
|
+
drafted: z.ZodOptional<z.ZodObject<{
|
|
5144
|
+
by: z.ZodEnum<{
|
|
5145
|
+
ai: "ai";
|
|
5146
|
+
person: "person";
|
|
5147
|
+
}>;
|
|
5148
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
5149
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5150
|
+
who: z.ZodOptional<z.ZodString>;
|
|
5151
|
+
at: z.ZodOptional<z.ZodString>;
|
|
5152
|
+
}, z.core.$strip>>;
|
|
5153
|
+
items: z.ZodArray<z.ZodObject<{
|
|
5154
|
+
id: z.ZodString;
|
|
5155
|
+
label: z.ZodString;
|
|
5156
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5157
|
+
}, z.core.$strip>>;
|
|
5158
|
+
}, z.core.$strip>>;
|
|
5159
|
+
corrections: z.ZodArray<z.ZodObject<{
|
|
5160
|
+
id: z.ZodString;
|
|
5161
|
+
stage: z.ZodString;
|
|
5162
|
+
file: z.ZodString;
|
|
5163
|
+
item: z.ZodOptional<z.ZodString>;
|
|
5164
|
+
label: z.ZodString;
|
|
5165
|
+
text: z.ZodString;
|
|
5166
|
+
scope: z.ZodEnum<{
|
|
5167
|
+
one: "one";
|
|
5168
|
+
similar: "similar";
|
|
5169
|
+
}>;
|
|
5170
|
+
like: z.ZodOptional<z.ZodString>;
|
|
5171
|
+
by: z.ZodString;
|
|
5172
|
+
at: z.ZodString;
|
|
5173
|
+
state: z.ZodEnum<{
|
|
5174
|
+
read: "read";
|
|
5175
|
+
applied: "applied";
|
|
5176
|
+
waiting: "waiting";
|
|
5177
|
+
}>;
|
|
5178
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5179
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
5180
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
5181
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5182
|
+
}, z.core.$strip>>;
|
|
5183
|
+
next: z.ZodObject<{
|
|
5184
|
+
stage: z.ZodString;
|
|
5185
|
+
command: z.ZodString;
|
|
5186
|
+
slash: z.ZodString;
|
|
5187
|
+
}, z.core.$strip>;
|
|
5188
|
+
problems: z.ZodArray<z.ZodObject<{
|
|
5189
|
+
file: z.ZodString;
|
|
5190
|
+
message: z.ZodString;
|
|
5191
|
+
}, z.core.$strip>>;
|
|
5192
|
+
}, z.core.$strip>;
|
|
5193
|
+
export declare const AddCorrectionRequest: z.ZodObject<{
|
|
5194
|
+
file: z.ZodString;
|
|
5195
|
+
item: z.ZodOptional<z.ZodString>;
|
|
5196
|
+
text: z.ZodString;
|
|
5197
|
+
similar: z.ZodDefault<z.ZodBoolean>;
|
|
5198
|
+
like: z.ZodOptional<z.ZodString>;
|
|
5199
|
+
}, z.core.$strict>;
|
|
5200
|
+
export declare const CorrectionResult: z.ZodObject<{
|
|
5201
|
+
correction: z.ZodObject<{
|
|
5202
|
+
id: z.ZodString;
|
|
5203
|
+
stage: z.ZodString;
|
|
5204
|
+
file: z.ZodString;
|
|
5205
|
+
item: z.ZodOptional<z.ZodString>;
|
|
5206
|
+
label: z.ZodString;
|
|
5207
|
+
text: z.ZodString;
|
|
5208
|
+
scope: z.ZodEnum<{
|
|
5209
|
+
one: "one";
|
|
5210
|
+
similar: "similar";
|
|
5211
|
+
}>;
|
|
5212
|
+
like: z.ZodOptional<z.ZodString>;
|
|
5213
|
+
by: z.ZodString;
|
|
5214
|
+
at: z.ZodString;
|
|
5215
|
+
state: z.ZodEnum<{
|
|
5216
|
+
read: "read";
|
|
5217
|
+
applied: "applied";
|
|
5218
|
+
waiting: "waiting";
|
|
5219
|
+
}>;
|
|
5220
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5221
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
5222
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
5223
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5224
|
+
}, z.core.$strip>;
|
|
5225
|
+
files: z.ZodArray<z.ZodString>;
|
|
5226
|
+
commit: z.ZodString;
|
|
5227
|
+
next: z.ZodObject<{
|
|
5228
|
+
stage: z.ZodString;
|
|
5229
|
+
command: z.ZodString;
|
|
5230
|
+
slash: z.ZodString;
|
|
5231
|
+
}, z.core.$strip>;
|
|
5232
|
+
}, z.core.$strip>;
|
|
5233
|
+
export declare const CorrectionList: z.ZodObject<{
|
|
5234
|
+
change: z.ZodString;
|
|
5235
|
+
corrections: z.ZodArray<z.ZodObject<{
|
|
5236
|
+
id: z.ZodString;
|
|
5237
|
+
stage: z.ZodString;
|
|
5238
|
+
file: z.ZodString;
|
|
5239
|
+
item: z.ZodOptional<z.ZodString>;
|
|
5240
|
+
label: z.ZodString;
|
|
5241
|
+
text: z.ZodString;
|
|
5242
|
+
scope: z.ZodEnum<{
|
|
5243
|
+
one: "one";
|
|
5244
|
+
similar: "similar";
|
|
5245
|
+
}>;
|
|
5246
|
+
like: z.ZodOptional<z.ZodString>;
|
|
5247
|
+
by: z.ZodString;
|
|
5248
|
+
at: z.ZodString;
|
|
5249
|
+
state: z.ZodEnum<{
|
|
5250
|
+
read: "read";
|
|
5251
|
+
applied: "applied";
|
|
5252
|
+
waiting: "waiting";
|
|
5253
|
+
}>;
|
|
5254
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5255
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
5256
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
5257
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5258
|
+
}, z.core.$strip>>;
|
|
5259
|
+
}, z.core.$strip>;
|
|
5260
|
+
export type StageDraftsViewT = z.infer<typeof StageDraftsView>;
|
|
5261
|
+
export type DraftFileViewT = z.infer<typeof DraftFileView>;
|
|
5262
|
+
export type DraftProvenanceT = z.infer<typeof DraftProvenance>;
|
|
5263
|
+
export type CorrectionViewT = z.infer<typeof CorrectionView>;
|
|
5264
|
+
export type CorrectionResultT = z.infer<typeof CorrectionResult>;
|
|
5265
|
+
export type CorrectionListT = z.infer<typeof CorrectionList>;
|
|
4433
5266
|
/**
|
|
4434
5267
|
* ADR 0092: the specs (ADR 0079) as the Flows screen reads them, from files only: the repos
|
|
4435
5268
|
* with a spec, one repo's flows, and one flow with the joins of the estate pass (ADR 0085).
|
|
@@ -4519,6 +5352,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4519
5352
|
document: "document";
|
|
4520
5353
|
export: "export";
|
|
4521
5354
|
manual: "manual";
|
|
5355
|
+
ai: "ai";
|
|
4522
5356
|
}>;
|
|
4523
5357
|
repo: z.ZodOptional<z.ZodString>;
|
|
4524
5358
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4535,6 +5369,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4535
5369
|
definition: "definition";
|
|
4536
5370
|
}>>;
|
|
4537
5371
|
by: z.ZodOptional<z.ZodString>;
|
|
5372
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4538
5373
|
}, z.core.$strict>>>;
|
|
4539
5374
|
flags: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
4540
5375
|
component: z.ZodString;
|
|
@@ -4567,6 +5402,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4567
5402
|
document: "document";
|
|
4568
5403
|
export: "export";
|
|
4569
5404
|
manual: "manual";
|
|
5405
|
+
ai: "ai";
|
|
4570
5406
|
}>;
|
|
4571
5407
|
repo: z.ZodOptional<z.ZodString>;
|
|
4572
5408
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4583,6 +5419,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4583
5419
|
definition: "definition";
|
|
4584
5420
|
}>>;
|
|
4585
5421
|
by: z.ZodOptional<z.ZodString>;
|
|
5422
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4586
5423
|
}, z.core.$strict>>>;
|
|
4587
5424
|
}, z.core.$strict>>;
|
|
4588
5425
|
evidence: z.ZodArray<z.ZodObject<{
|
|
@@ -4599,6 +5436,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4599
5436
|
document: "document";
|
|
4600
5437
|
export: "export";
|
|
4601
5438
|
manual: "manual";
|
|
5439
|
+
ai: "ai";
|
|
4602
5440
|
}>;
|
|
4603
5441
|
repo: z.ZodOptional<z.ZodString>;
|
|
4604
5442
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4615,6 +5453,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4615
5453
|
definition: "definition";
|
|
4616
5454
|
}>>;
|
|
4617
5455
|
by: z.ZodOptional<z.ZodString>;
|
|
5456
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4618
5457
|
}, z.core.$strict>>;
|
|
4619
5458
|
}, z.core.$strict>;
|
|
4620
5459
|
steps: z.ZodArray<z.ZodObject<{
|
|
@@ -4665,6 +5504,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4665
5504
|
document: "document";
|
|
4666
5505
|
export: "export";
|
|
4667
5506
|
manual: "manual";
|
|
5507
|
+
ai: "ai";
|
|
4668
5508
|
}>;
|
|
4669
5509
|
repo: z.ZodOptional<z.ZodString>;
|
|
4670
5510
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4681,6 +5521,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4681
5521
|
definition: "definition";
|
|
4682
5522
|
}>>;
|
|
4683
5523
|
by: z.ZodOptional<z.ZodString>;
|
|
5524
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4684
5525
|
}, z.core.$strict>>;
|
|
4685
5526
|
confirmedBy: z.ZodOptional<z.ZodEnum<{
|
|
4686
5527
|
check: "check";
|
|
@@ -4709,6 +5550,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4709
5550
|
document: "document";
|
|
4710
5551
|
export: "export";
|
|
4711
5552
|
manual: "manual";
|
|
5553
|
+
ai: "ai";
|
|
4712
5554
|
}>;
|
|
4713
5555
|
repo: z.ZodOptional<z.ZodString>;
|
|
4714
5556
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4725,6 +5567,7 @@ export declare const FlowView: z.ZodObject<{
|
|
|
4725
5567
|
definition: "definition";
|
|
4726
5568
|
}>>;
|
|
4727
5569
|
by: z.ZodOptional<z.ZodString>;
|
|
5570
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4728
5571
|
}, z.core.$strict>>;
|
|
4729
5572
|
confirmedBy: z.ZodOptional<z.ZodEnum<{
|
|
4730
5573
|
check: "check";
|
|
@@ -4823,8 +5666,8 @@ export declare const TargetFlowList: z.ZodObject<{
|
|
|
4823
5666
|
}, z.core.$strip>;
|
|
4824
5667
|
export declare const MergedStep: z.ZodObject<{
|
|
4825
5668
|
mark: z.ZodEnum<{
|
|
4826
|
-
same: "same";
|
|
4827
5669
|
added: "added";
|
|
5670
|
+
same: "same";
|
|
4828
5671
|
changed: "changed";
|
|
4829
5672
|
removed: "removed";
|
|
4830
5673
|
}>;
|
|
@@ -4869,6 +5712,7 @@ export declare const MergedStep: z.ZodObject<{
|
|
|
4869
5712
|
document: "document";
|
|
4870
5713
|
export: "export";
|
|
4871
5714
|
manual: "manual";
|
|
5715
|
+
ai: "ai";
|
|
4872
5716
|
}>;
|
|
4873
5717
|
repo: z.ZodOptional<z.ZodString>;
|
|
4874
5718
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4885,6 +5729,7 @@ export declare const MergedStep: z.ZodObject<{
|
|
|
4885
5729
|
definition: "definition";
|
|
4886
5730
|
}>>;
|
|
4887
5731
|
by: z.ZodOptional<z.ZodString>;
|
|
5732
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4888
5733
|
}, z.core.$strict>>;
|
|
4889
5734
|
confirmedBy: z.ZodOptional<z.ZodString>;
|
|
4890
5735
|
was: z.ZodOptional<z.ZodObject<{
|
|
@@ -4931,6 +5776,7 @@ export declare const TargetFlowView: z.ZodObject<{
|
|
|
4931
5776
|
document: "document";
|
|
4932
5777
|
export: "export";
|
|
4933
5778
|
manual: "manual";
|
|
5779
|
+
ai: "ai";
|
|
4934
5780
|
}>;
|
|
4935
5781
|
repo: z.ZodOptional<z.ZodString>;
|
|
4936
5782
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4947,6 +5793,7 @@ export declare const TargetFlowView: z.ZodObject<{
|
|
|
4947
5793
|
definition: "definition";
|
|
4948
5794
|
}>>;
|
|
4949
5795
|
by: z.ZodOptional<z.ZodString>;
|
|
5796
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4950
5797
|
}, z.core.$strict>>>;
|
|
4951
5798
|
}, z.core.$strict>>;
|
|
4952
5799
|
}, z.core.$strip>;
|
|
@@ -4964,6 +5811,7 @@ export declare const TargetFlowView: z.ZodObject<{
|
|
|
4964
5811
|
document: "document";
|
|
4965
5812
|
export: "export";
|
|
4966
5813
|
manual: "manual";
|
|
5814
|
+
ai: "ai";
|
|
4967
5815
|
}>;
|
|
4968
5816
|
repo: z.ZodOptional<z.ZodString>;
|
|
4969
5817
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -4980,11 +5828,12 @@ export declare const TargetFlowView: z.ZodObject<{
|
|
|
4980
5828
|
definition: "definition";
|
|
4981
5829
|
}>>;
|
|
4982
5830
|
by: z.ZodOptional<z.ZodString>;
|
|
5831
|
+
run: z.ZodOptional<z.ZodString>;
|
|
4983
5832
|
}, z.core.$strict>>;
|
|
4984
5833
|
steps: z.ZodArray<z.ZodObject<{
|
|
4985
5834
|
mark: z.ZodEnum<{
|
|
4986
|
-
same: "same";
|
|
4987
5835
|
added: "added";
|
|
5836
|
+
same: "same";
|
|
4988
5837
|
changed: "changed";
|
|
4989
5838
|
removed: "removed";
|
|
4990
5839
|
}>;
|
|
@@ -5029,6 +5878,7 @@ export declare const TargetFlowView: z.ZodObject<{
|
|
|
5029
5878
|
document: "document";
|
|
5030
5879
|
export: "export";
|
|
5031
5880
|
manual: "manual";
|
|
5881
|
+
ai: "ai";
|
|
5032
5882
|
}>;
|
|
5033
5883
|
repo: z.ZodOptional<z.ZodString>;
|
|
5034
5884
|
path: z.ZodOptional<z.ZodString>;
|
|
@@ -5045,6 +5895,7 @@ export declare const TargetFlowView: z.ZodObject<{
|
|
|
5045
5895
|
definition: "definition";
|
|
5046
5896
|
}>>;
|
|
5047
5897
|
by: z.ZodOptional<z.ZodString>;
|
|
5898
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5048
5899
|
}, z.core.$strict>>;
|
|
5049
5900
|
confirmedBy: z.ZodOptional<z.ZodString>;
|
|
5050
5901
|
was: z.ZodOptional<z.ZodObject<{
|
|
@@ -5192,6 +6043,7 @@ export declare const ChangeImpact: z.ZodObject<{
|
|
|
5192
6043
|
flows: z.ZodNumber;
|
|
5193
6044
|
breaks: z.ZodNumber;
|
|
5194
6045
|
mayBreak: z.ZodNumber;
|
|
6046
|
+
byAi: z.ZodOptional<z.ZodNumber>;
|
|
5195
6047
|
routes: z.ZodNumber;
|
|
5196
6048
|
upstream: z.ZodOptional<z.ZodObject<{
|
|
5197
6049
|
breaks: z.ZodNumber;
|
|
@@ -5233,6 +6085,7 @@ export declare const ChangeImpact: z.ZodObject<{
|
|
|
5233
6085
|
"joined-despite-conflict": "joined-despite-conflict";
|
|
5234
6086
|
"joined-by-service-name": "joined-by-service-name";
|
|
5235
6087
|
}>>;
|
|
6088
|
+
decidedByAi: z.ZodOptional<z.ZodLiteral<true>>;
|
|
5236
6089
|
interfaces: z.ZodArray<z.ZodString>;
|
|
5237
6090
|
flows: z.ZodArray<z.ZodString>;
|
|
5238
6091
|
routes: z.ZodArray<z.ZodString>;
|
|
@@ -5527,6 +6380,7 @@ export declare const RepoBranchesView: z.ZodObject<{
|
|
|
5527
6380
|
scannedAt: z.ZodString;
|
|
5528
6381
|
commit: z.ZodString;
|
|
5529
6382
|
}, z.core.$strip>>;
|
|
6383
|
+
build: z.ZodOptional<z.ZodString>;
|
|
5530
6384
|
}, z.core.$strip>;
|
|
5531
6385
|
export declare const RepoBranchesList: z.ZodObject<{
|
|
5532
6386
|
repos: z.ZodArray<z.ZodObject<{
|
|
@@ -5557,6 +6411,7 @@ export declare const RepoBranchesList: z.ZodObject<{
|
|
|
5557
6411
|
scannedAt: z.ZodString;
|
|
5558
6412
|
commit: z.ZodString;
|
|
5559
6413
|
}, z.core.$strip>>;
|
|
6414
|
+
build: z.ZodOptional<z.ZodString>;
|
|
5560
6415
|
}, z.core.$strip>>;
|
|
5561
6416
|
}, z.core.$strip>;
|
|
5562
6417
|
/** What a branch's catalog changes against the baseline, for the repos it read. */
|
|
@@ -5577,6 +6432,23 @@ export declare const BranchCompare: z.ZodObject<{
|
|
|
5577
6432
|
export declare const EditRepoBranchesRequest: z.ZodObject<{
|
|
5578
6433
|
defaultBranch: z.ZodOptional<z.ZodString>;
|
|
5579
6434
|
branches: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6435
|
+
was: z.ZodOptional<z.ZodObject<{
|
|
6436
|
+
defaultBranch: z.ZodString;
|
|
6437
|
+
branches: z.ZodArray<z.ZodString>;
|
|
6438
|
+
}, z.core.$strict>>;
|
|
6439
|
+
}, z.core.$strict>;
|
|
6440
|
+
/**
|
|
6441
|
+
* 2.74.0: a repo's build command in its manifest, set on a person's click; empty clears it. `was`
|
|
6442
|
+
* is the command the form showed ("" for none): 409 when the manifest says otherwise now.
|
|
6443
|
+
*/
|
|
6444
|
+
export declare const EditRepoBuildRequest: z.ZodObject<{
|
|
6445
|
+
build: z.ZodString;
|
|
6446
|
+
was: z.ZodOptional<z.ZodString>;
|
|
6447
|
+
}, z.core.$strict>;
|
|
6448
|
+
/** 2.74.0: who looks after the org pack (pack.yaml's owner), set on a person's click. */
|
|
6449
|
+
export declare const SetOrgPackOwnerRequest: z.ZodObject<{
|
|
6450
|
+
owner: z.ZodString;
|
|
6451
|
+
was: z.ZodOptional<z.ZodString>;
|
|
5580
6452
|
}, z.core.$strict>;
|
|
5581
6453
|
/** WP7.5: follow a change, or stop following it (the person's own .atticus/me.yaml). */
|
|
5582
6454
|
export declare const WatchRequest: z.ZodObject<{
|
|
@@ -5603,6 +6475,7 @@ export declare const ChangeCockpit: z.ZodObject<{
|
|
|
5603
6475
|
command: z.ZodString;
|
|
5604
6476
|
slash: z.ZodOptional<z.ZodString>;
|
|
5605
6477
|
why: z.ZodString;
|
|
6478
|
+
pr: z.ZodOptional<z.ZodString>;
|
|
5606
6479
|
}, z.core.$loose>>;
|
|
5607
6480
|
nextStep: z.ZodString;
|
|
5608
6481
|
reasons: z.ZodArray<z.ZodObject<{
|
|
@@ -5626,6 +6499,18 @@ export declare const ChangeCockpit: z.ZodObject<{
|
|
|
5626
6499
|
openQuestions: z.ZodNumber;
|
|
5627
6500
|
}, z.core.$strip>>;
|
|
5628
6501
|
openQuestions: z.ZodNumber;
|
|
6502
|
+
openQuestionsByRole: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
|
|
6503
|
+
product: "product";
|
|
6504
|
+
architecture: "architecture";
|
|
6505
|
+
delivery: "delivery";
|
|
6506
|
+
analysis: "analysis";
|
|
6507
|
+
}> & z.core.$partial, z.ZodNumber>>;
|
|
6508
|
+
yourRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
6509
|
+
product: "product";
|
|
6510
|
+
architecture: "architecture";
|
|
6511
|
+
delivery: "delivery";
|
|
6512
|
+
analysis: "analysis";
|
|
6513
|
+
}>>>;
|
|
5629
6514
|
repos: z.ZodArray<z.ZodObject<{
|
|
5630
6515
|
id: z.ZodString;
|
|
5631
6516
|
branch: z.ZodString;
|
|
@@ -5647,31 +6532,194 @@ export declare const NewChangeRequest: z.ZodObject<{
|
|
|
5647
6532
|
template: z.ZodOptional<z.ZodString>;
|
|
5648
6533
|
like: z.ZodOptional<z.ZodString>;
|
|
5649
6534
|
}, z.core.$strict>;
|
|
5650
|
-
/**
|
|
5651
|
-
export declare const
|
|
5652
|
-
|
|
5653
|
-
|
|
5654
|
-
|
|
5655
|
-
|
|
5656
|
-
|
|
5657
|
-
|
|
5658
|
-
|
|
5659
|
-
|
|
5660
|
-
|
|
5661
|
-
|
|
5662
|
-
|
|
5663
|
-
|
|
5664
|
-
|
|
6535
|
+
/** 2.65.0 (ADR 0183): what Propose for review commits, and the person's yes to it. */
|
|
6536
|
+
export declare const ProposeScope: z.ZodEnum<{
|
|
6537
|
+
"service-desk": "service-desk";
|
|
6538
|
+
"org-pack": "org-pack";
|
|
6539
|
+
audit: "audit";
|
|
6540
|
+
corrections: "corrections";
|
|
6541
|
+
answers: "answers";
|
|
6542
|
+
work: "work";
|
|
6543
|
+
"owner-answers": "owner-answers";
|
|
6544
|
+
baseline: "baseline";
|
|
6545
|
+
initiatives: "initiatives";
|
|
6546
|
+
outcomes: "outcomes";
|
|
6547
|
+
}>;
|
|
6548
|
+
export declare const ProposePlanView: z.ZodObject<{
|
|
6549
|
+
scope: z.ZodEnum<{
|
|
6550
|
+
"service-desk": "service-desk";
|
|
6551
|
+
"org-pack": "org-pack";
|
|
6552
|
+
audit: "audit";
|
|
6553
|
+
corrections: "corrections";
|
|
6554
|
+
answers: "answers";
|
|
6555
|
+
work: "work";
|
|
6556
|
+
"owner-answers": "owner-answers";
|
|
6557
|
+
baseline: "baseline";
|
|
6558
|
+
initiatives: "initiatives";
|
|
6559
|
+
outcomes: "outcomes";
|
|
5665
6560
|
}>;
|
|
5666
|
-
|
|
5667
|
-
|
|
5668
|
-
|
|
5669
|
-
|
|
5670
|
-
|
|
5671
|
-
|
|
5672
|
-
|
|
5673
|
-
|
|
5674
|
-
|
|
6561
|
+
files: z.ZodArray<z.ZodObject<{
|
|
6562
|
+
path: z.ZodString;
|
|
6563
|
+
status: z.ZodString;
|
|
6564
|
+
from: z.ZodOptional<z.ZodString>;
|
|
6565
|
+
proposed: z.ZodOptional<z.ZodString>;
|
|
6566
|
+
}, z.core.$strip>>;
|
|
6567
|
+
branch: z.ZodString;
|
|
6568
|
+
title: z.ZodString;
|
|
6569
|
+
applyFirst: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6570
|
+
}, z.core.$strip>;
|
|
6571
|
+
export declare const ProposeRequest: z.ZodObject<{
|
|
6572
|
+
scope: z.ZodEnum<{
|
|
6573
|
+
"service-desk": "service-desk";
|
|
6574
|
+
"org-pack": "org-pack";
|
|
6575
|
+
audit: "audit";
|
|
6576
|
+
corrections: "corrections";
|
|
6577
|
+
answers: "answers";
|
|
6578
|
+
work: "work";
|
|
6579
|
+
"owner-answers": "owner-answers";
|
|
6580
|
+
baseline: "baseline";
|
|
6581
|
+
initiatives: "initiatives";
|
|
6582
|
+
outcomes: "outcomes";
|
|
6583
|
+
}>;
|
|
6584
|
+
files: z.ZodArray<z.ZodString>;
|
|
6585
|
+
title: z.ZodOptional<z.ZodString>;
|
|
6586
|
+
branch: z.ZodOptional<z.ZodString>;
|
|
6587
|
+
}, z.core.$strict>;
|
|
6588
|
+
export declare const LinesView: z.ZodObject<{
|
|
6589
|
+
code: z.ZodOptional<z.ZodNumber>;
|
|
6590
|
+
lines: z.ZodArray<z.ZodString>;
|
|
6591
|
+
}, z.core.$strip>;
|
|
6592
|
+
/**
|
|
6593
|
+
* 2.67.0 (UX review, 2026-11-08): a knowledge gap's owner question (ADR 0021), as the Questions
|
|
6594
|
+
* page lists it and answers it. The answer is written to `file`, a curated OwnerQuestion record
|
|
6595
|
+
* (the same `atticus questions owner <id> --text` writes); the gap closes once the fact is in
|
|
6596
|
+
* the catalog.
|
|
6597
|
+
*/
|
|
6598
|
+
export declare const OwnerQuestionView: z.ZodObject<{
|
|
6599
|
+
id: z.ZodString;
|
|
6600
|
+
system: z.ZodString;
|
|
6601
|
+
owner: z.ZodString;
|
|
6602
|
+
question: z.ZodString;
|
|
6603
|
+
neededFact: z.ZodString;
|
|
6604
|
+
channel: z.ZodString;
|
|
6605
|
+
state: z.ZodEnum<{
|
|
6606
|
+
sent: "sent";
|
|
6607
|
+
answered: "answered";
|
|
6608
|
+
overdue: "overdue";
|
|
6609
|
+
}>;
|
|
6610
|
+
answer: z.ZodOptional<z.ZodString>;
|
|
6611
|
+
routeTo: z.ZodOptional<z.ZodString>;
|
|
6612
|
+
fill: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6613
|
+
file: z.ZodString;
|
|
6614
|
+
field: z.ZodString;
|
|
6615
|
+
what: z.ZodString;
|
|
6616
|
+
}, z.core.$strip>>>;
|
|
6617
|
+
records: z.ZodArray<z.ZodString>;
|
|
6618
|
+
file: z.ZodString;
|
|
6619
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
6620
|
+
change: z.ZodString;
|
|
6621
|
+
gate: z.ZodString;
|
|
6622
|
+
id: z.ZodString;
|
|
6623
|
+
}, z.core.$strip>>;
|
|
6624
|
+
}, z.core.$strip>;
|
|
6625
|
+
export declare const OwnerQuestionList: z.ZodObject<{
|
|
6626
|
+
empty: z.ZodBoolean;
|
|
6627
|
+
open: z.ZodNumber;
|
|
6628
|
+
questions: z.ZodArray<z.ZodObject<{
|
|
6629
|
+
id: z.ZodString;
|
|
6630
|
+
system: z.ZodString;
|
|
6631
|
+
owner: z.ZodString;
|
|
6632
|
+
question: z.ZodString;
|
|
6633
|
+
neededFact: z.ZodString;
|
|
6634
|
+
channel: z.ZodString;
|
|
6635
|
+
state: z.ZodEnum<{
|
|
6636
|
+
sent: "sent";
|
|
6637
|
+
answered: "answered";
|
|
6638
|
+
overdue: "overdue";
|
|
6639
|
+
}>;
|
|
6640
|
+
answer: z.ZodOptional<z.ZodString>;
|
|
6641
|
+
routeTo: z.ZodOptional<z.ZodString>;
|
|
6642
|
+
fill: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6643
|
+
file: z.ZodString;
|
|
6644
|
+
field: z.ZodString;
|
|
6645
|
+
what: z.ZodString;
|
|
6646
|
+
}, z.core.$strip>>>;
|
|
6647
|
+
records: z.ZodArray<z.ZodString>;
|
|
6648
|
+
file: z.ZodString;
|
|
6649
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
6650
|
+
change: z.ZodString;
|
|
6651
|
+
gate: z.ZodString;
|
|
6652
|
+
id: z.ZodString;
|
|
6653
|
+
}, z.core.$strip>>;
|
|
6654
|
+
}, z.core.$strip>>;
|
|
6655
|
+
}, z.core.$strip>;
|
|
6656
|
+
export declare const OwnerAnswerRequest: z.ZodObject<{
|
|
6657
|
+
answer: z.ZodString;
|
|
6658
|
+
}, z.core.$strict>;
|
|
6659
|
+
export declare const OwnerAnswerResult: z.ZodObject<{
|
|
6660
|
+
file: z.ZodString;
|
|
6661
|
+
question: z.ZodObject<{
|
|
6662
|
+
id: z.ZodString;
|
|
6663
|
+
system: z.ZodString;
|
|
6664
|
+
owner: z.ZodString;
|
|
6665
|
+
question: z.ZodString;
|
|
6666
|
+
neededFact: z.ZodString;
|
|
6667
|
+
channel: z.ZodString;
|
|
6668
|
+
state: z.ZodEnum<{
|
|
6669
|
+
sent: "sent";
|
|
6670
|
+
answered: "answered";
|
|
6671
|
+
overdue: "overdue";
|
|
6672
|
+
}>;
|
|
6673
|
+
answer: z.ZodOptional<z.ZodString>;
|
|
6674
|
+
routeTo: z.ZodOptional<z.ZodString>;
|
|
6675
|
+
fill: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6676
|
+
file: z.ZodString;
|
|
6677
|
+
field: z.ZodString;
|
|
6678
|
+
what: z.ZodString;
|
|
6679
|
+
}, z.core.$strip>>>;
|
|
6680
|
+
records: z.ZodArray<z.ZodString>;
|
|
6681
|
+
file: z.ZodString;
|
|
6682
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
6683
|
+
change: z.ZodString;
|
|
6684
|
+
gate: z.ZodString;
|
|
6685
|
+
id: z.ZodString;
|
|
6686
|
+
}, z.core.$strip>>;
|
|
6687
|
+
}, z.core.$strip>;
|
|
6688
|
+
}, z.core.$strip>;
|
|
6689
|
+
export type OwnerQuestionViewT = z.infer<typeof OwnerQuestionView>;
|
|
6690
|
+
export type OwnerQuestionListT = z.infer<typeof OwnerQuestionList>;
|
|
6691
|
+
export type OwnerAnswerResultT = z.infer<typeof OwnerAnswerResult>;
|
|
6692
|
+
/** 2.64.0: a change type, as the New change form offers it. */
|
|
6693
|
+
export declare const ChangeTypeView: z.ZodObject<{
|
|
6694
|
+
id: z.ZodString;
|
|
6695
|
+
name: z.ZodString;
|
|
6696
|
+
description: z.ZodOptional<z.ZodString>;
|
|
6697
|
+
}, z.core.$strip>;
|
|
6698
|
+
/** WP7.6: an archived change near a new brief. */
|
|
6699
|
+
export declare const PastChange: z.ZodObject<{
|
|
6700
|
+
id: z.ZodString;
|
|
6701
|
+
change: z.ZodString;
|
|
6702
|
+
title: z.ZodString;
|
|
6703
|
+
archived: z.ZodOptional<z.ZodString>;
|
|
6704
|
+
summary: z.ZodString;
|
|
6705
|
+
file: z.ZodString;
|
|
6706
|
+
score: z.ZodNumber;
|
|
6707
|
+
}, z.core.$strip>;
|
|
6708
|
+
/** WP7.6: the archived changes nearest a new brief, by meaning or, where that is off, by words. */
|
|
6709
|
+
export declare const SimilarChanges: z.ZodObject<{
|
|
6710
|
+
how: z.ZodEnum<{
|
|
6711
|
+
meaning: "meaning";
|
|
6712
|
+
words: "words";
|
|
6713
|
+
}>;
|
|
6714
|
+
note: z.ZodOptional<z.ZodString>;
|
|
6715
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
6716
|
+
id: z.ZodString;
|
|
6717
|
+
change: z.ZodString;
|
|
6718
|
+
title: z.ZodString;
|
|
6719
|
+
archived: z.ZodOptional<z.ZodString>;
|
|
6720
|
+
summary: z.ZodString;
|
|
6721
|
+
file: z.ZodString;
|
|
6722
|
+
score: z.ZodNumber;
|
|
5675
6723
|
}, z.core.$strip>>;
|
|
5676
6724
|
}, z.core.$strip>;
|
|
5677
6725
|
export type SimilarChangesT = z.infer<typeof SimilarChanges>;
|
|
@@ -6368,7 +7416,146 @@ export declare const ChangePrototypeList: z.ZodObject<{
|
|
|
6368
7416
|
}, z.core.$strip>>;
|
|
6369
7417
|
problem: z.ZodOptional<z.ZodString>;
|
|
6370
7418
|
}, z.core.$strip>>;
|
|
7419
|
+
candidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7420
|
+
}, z.core.$strip>;
|
|
7421
|
+
/** Round 36: compare a prototype from the app, as `atticus change attach <change> --prototype <repo>`. */
|
|
7422
|
+
export declare const ComparePrototypeRequest: z.ZodObject<{
|
|
7423
|
+
repo: z.ZodString;
|
|
7424
|
+
}, z.core.$strict>;
|
|
7425
|
+
/** The prototypes attached now, and what the command printed (the four groups, the footprint). */
|
|
7426
|
+
export declare const ComparePrototypeView: z.ZodObject<{
|
|
7427
|
+
prototypes: z.ZodArray<z.ZodObject<{
|
|
7428
|
+
repo: z.ZodString;
|
|
7429
|
+
attached: z.ZodString;
|
|
7430
|
+
about: z.ZodOptional<z.ZodObject<{
|
|
7431
|
+
text: z.ZodString;
|
|
7432
|
+
trust: z.ZodEnum<{
|
|
7433
|
+
verified: "verified";
|
|
7434
|
+
suggested: "suggested";
|
|
7435
|
+
}>;
|
|
7436
|
+
}, z.core.$strip>>;
|
|
7437
|
+
comparison: z.ZodOptional<z.ZodObject<{
|
|
7438
|
+
prototype: z.ZodString;
|
|
7439
|
+
counts: z.ZodObject<{
|
|
7440
|
+
exists: z.ZodNumber;
|
|
7441
|
+
changes: z.ZodNumber;
|
|
7442
|
+
new: z.ZodNumber;
|
|
7443
|
+
vendor: z.ZodNumber;
|
|
7444
|
+
}, z.core.$strip>;
|
|
7445
|
+
calls: z.ZodArray<z.ZodObject<{
|
|
7446
|
+
id: z.ZodString;
|
|
7447
|
+
leg: z.ZodEnum<{
|
|
7448
|
+
"ui-bff": "ui-bff";
|
|
7449
|
+
"bff-mock": "bff-mock";
|
|
7450
|
+
}>;
|
|
7451
|
+
group: z.ZodEnum<{
|
|
7452
|
+
vendor: "vendor";
|
|
7453
|
+
changes: "changes";
|
|
7454
|
+
new: "new";
|
|
7455
|
+
exists: "exists";
|
|
7456
|
+
}>;
|
|
7457
|
+
method: z.ZodOptional<z.ZodString>;
|
|
7458
|
+
path: z.ZodString;
|
|
7459
|
+
call: z.ZodObject<{
|
|
7460
|
+
repo: z.ZodString;
|
|
7461
|
+
fact: z.ZodString;
|
|
7462
|
+
component: z.ZodString;
|
|
7463
|
+
at: z.ZodString;
|
|
7464
|
+
}, z.core.$strip>;
|
|
7465
|
+
lands: z.ZodObject<{
|
|
7466
|
+
repo: z.ZodString;
|
|
7467
|
+
fact: z.ZodString;
|
|
7468
|
+
component: z.ZodString;
|
|
7469
|
+
at: z.ZodString;
|
|
7470
|
+
}, z.core.$strip>;
|
|
7471
|
+
auth: z.ZodOptional<z.ZodString>;
|
|
7472
|
+
scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7473
|
+
estate: z.ZodOptional<z.ZodObject<{
|
|
7474
|
+
entry: z.ZodObject<{
|
|
7475
|
+
repo: z.ZodString;
|
|
7476
|
+
fact: z.ZodString;
|
|
7477
|
+
component: z.ZodString;
|
|
7478
|
+
at: z.ZodString;
|
|
7479
|
+
}, z.core.$strip>;
|
|
7480
|
+
endpoint: z.ZodString;
|
|
7481
|
+
how: z.ZodString;
|
|
7482
|
+
gateway: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7483
|
+
auth: z.ZodOptional<z.ZodString>;
|
|
7484
|
+
scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7485
|
+
}, z.core.$strip>>;
|
|
7486
|
+
vendor: z.ZodOptional<z.ZodObject<{
|
|
7487
|
+
system: z.ZodString;
|
|
7488
|
+
name: z.ZodString;
|
|
7489
|
+
operation: z.ZodString;
|
|
7490
|
+
method: z.ZodString;
|
|
7491
|
+
path: z.ZodString;
|
|
7492
|
+
at: z.ZodOptional<z.ZodString>;
|
|
7493
|
+
through: z.ZodArray<z.ZodString>;
|
|
7494
|
+
boundary: z.ZodOptional<z.ZodEnum<{
|
|
7495
|
+
internal: "internal";
|
|
7496
|
+
vendor: "vendor";
|
|
7497
|
+
}>>;
|
|
7498
|
+
}, z.core.$strip>>;
|
|
7499
|
+
candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
7500
|
+
repo: z.ZodString;
|
|
7501
|
+
fact: z.ZodString;
|
|
7502
|
+
component: z.ZodString;
|
|
7503
|
+
at: z.ZodString;
|
|
7504
|
+
}, z.core.$strip>>>;
|
|
7505
|
+
differences: z.ZodArray<z.ZodObject<{
|
|
7506
|
+
kind: z.ZodEnum<{
|
|
7507
|
+
auth: "auth";
|
|
7508
|
+
"field-missing": "field-missing";
|
|
7509
|
+
"field-required": "field-required";
|
|
7510
|
+
"field-type": "field-type";
|
|
7511
|
+
"field-enum": "field-enum";
|
|
7512
|
+
"header-missing": "header-missing";
|
|
7513
|
+
"header-required": "header-required";
|
|
7514
|
+
"error-missing": "error-missing";
|
|
7515
|
+
"error-unhandled": "error-unhandled";
|
|
7516
|
+
"scope-missing": "scope-missing";
|
|
7517
|
+
}>;
|
|
7518
|
+
side: z.ZodOptional<z.ZodEnum<{
|
|
7519
|
+
request: "request";
|
|
7520
|
+
response: "response";
|
|
7521
|
+
}>>;
|
|
7522
|
+
field: z.ZodOptional<z.ZodString>;
|
|
7523
|
+
scope: z.ZodOptional<z.ZodString>;
|
|
7524
|
+
value: z.ZodOptional<z.ZodString>;
|
|
7525
|
+
status: z.ZodOptional<z.ZodString>;
|
|
7526
|
+
prototype: z.ZodObject<{
|
|
7527
|
+
value: z.ZodString;
|
|
7528
|
+
at: z.ZodString;
|
|
7529
|
+
}, z.core.$strip>;
|
|
7530
|
+
estate: z.ZodOptional<z.ZodObject<{
|
|
7531
|
+
value: z.ZodString;
|
|
7532
|
+
at: z.ZodString;
|
|
7533
|
+
}, z.core.$strip>>;
|
|
7534
|
+
message: z.ZodString;
|
|
7535
|
+
}, z.core.$strip>>;
|
|
7536
|
+
sentence: z.ZodString;
|
|
7537
|
+
}, z.core.$strip>>;
|
|
7538
|
+
repos: z.ZodArray<z.ZodString>;
|
|
7539
|
+
uses: z.ZodArray<z.ZodString>;
|
|
7540
|
+
endpoints: z.ZodArray<z.ZodString>;
|
|
7541
|
+
vendorOperations: z.ZodArray<z.ZodString>;
|
|
7542
|
+
vendors: z.ZodArray<z.ZodString>;
|
|
7543
|
+
left: z.ZodArray<z.ZodObject<{
|
|
7544
|
+
call: z.ZodObject<{
|
|
7545
|
+
repo: z.ZodString;
|
|
7546
|
+
fact: z.ZodString;
|
|
7547
|
+
component: z.ZodString;
|
|
7548
|
+
at: z.ZodString;
|
|
7549
|
+
}, z.core.$strip>;
|
|
7550
|
+
why: z.ZodString;
|
|
7551
|
+
}, z.core.$strip>>;
|
|
7552
|
+
}, z.core.$strip>>;
|
|
7553
|
+
problem: z.ZodOptional<z.ZodString>;
|
|
7554
|
+
}, z.core.$strip>>;
|
|
7555
|
+
candidates: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7556
|
+
lines: z.ZodArray<z.ZodString>;
|
|
6371
7557
|
}, z.core.$strip>;
|
|
7558
|
+
export type ComparePrototypeViewT = z.infer<typeof ComparePrototypeView>;
|
|
6372
7559
|
export type PrototypeCallViewT = z.infer<typeof PrototypeCallView>;
|
|
6373
7560
|
export type ChangePrototypeT = z.infer<typeof ChangePrototype>;
|
|
6374
7561
|
export type ChangePrototypeListT = z.infer<typeof ChangePrototypeList>;
|
|
@@ -6425,30 +7612,123 @@ export declare const HandoffRequest: z.ZodObject<{
|
|
|
6425
7612
|
export declare const SyncRequest: z.ZodObject<{
|
|
6426
7613
|
repo: z.ZodOptional<z.ZodString>;
|
|
6427
7614
|
}, z.core.$strict>;
|
|
6428
|
-
/** ADR
|
|
6429
|
-
export declare const
|
|
6430
|
-
|
|
6431
|
-
|
|
6432
|
-
|
|
6433
|
-
change: z.ZodOptional<z.ZodString>;
|
|
6434
|
-
}, z.core.$strict>;
|
|
6435
|
-
export declare const StepRunRequest: z.ZodObject<{
|
|
6436
|
-
with: z.ZodString;
|
|
6437
|
-
inputsSha256: z.ZodString;
|
|
6438
|
-
fillOnly: z.ZodOptional<z.ZodBoolean>;
|
|
6439
|
-
change: z.ZodOptional<z.ZodString>;
|
|
6440
|
-
}, z.core.$strict>;
|
|
6441
|
-
export declare const ArchiveRequest: z.ZodObject<{
|
|
6442
|
-
rescan: z.ZodOptional<z.ZodBoolean>;
|
|
6443
|
-
}, z.core.$strict>;
|
|
6444
|
-
export declare const DraftRequestsRequest: z.ZodObject<{
|
|
6445
|
-
force: z.ZodOptional<z.ZodBoolean>;
|
|
7615
|
+
/** ADR 0184: raise the release PRs, change/<id> into each code repo's default branch. */
|
|
7616
|
+
export declare const ReleasePrsRequest: z.ZodObject<{}, z.core.$strict>;
|
|
7617
|
+
/** 2.75.0 (seventh UX walk): tick (done) or untick a task in the change's tasks.md. */
|
|
7618
|
+
export declare const TaskDoneRequest: z.ZodObject<{
|
|
7619
|
+
done: z.ZodBoolean;
|
|
6446
7620
|
}, z.core.$strict>;
|
|
6447
|
-
/**
|
|
6448
|
-
|
|
6449
|
-
|
|
6450
|
-
|
|
6451
|
-
|
|
7621
|
+
/**
|
|
7622
|
+
* 2.83.0 (ninth UX walk): name a change's owners per role from the change page (an empty list
|
|
7623
|
+
* clears a role): the product owner, the architect, the business analyst and the tech lead
|
|
7624
|
+
* (team-lead). Other owner keys of change.yaml are kept.
|
|
7625
|
+
*/
|
|
7626
|
+
export declare const CHANGE_OWNER_ROLES: readonly ["product-owner", "architect", "business-analyst", "team-lead"];
|
|
7627
|
+
export declare const ChangeOwnersRequest: z.ZodObject<{
|
|
7628
|
+
owners: z.ZodRecord<z.ZodEnum<{
|
|
7629
|
+
"product-owner": "product-owner";
|
|
7630
|
+
"business-analyst": "business-analyst";
|
|
7631
|
+
architect: "architect";
|
|
7632
|
+
"team-lead": "team-lead";
|
|
7633
|
+
}> & z.core.$partial, z.ZodArray<z.ZodString>>;
|
|
7634
|
+
}, z.core.$strict>;
|
|
7635
|
+
/**
|
|
7636
|
+
* 2.79.0 (ADR 0181 part 4): Run all ready tasks. Every task not done yet, in the cross-repo order
|
|
7637
|
+
* (the deployment plan's order of the repos, else tasks.md's), ready to run or why not: a task
|
|
7638
|
+
* waits for the tasks of the stories its story depends on, and one already run waits on its PR,
|
|
7639
|
+
* the assistant or a person.
|
|
7640
|
+
*/
|
|
7641
|
+
export declare const ReadyTasks: z.ZodObject<{
|
|
7642
|
+
change: z.ZodString;
|
|
7643
|
+
tasks: z.ZodArray<z.ZodObject<{
|
|
7644
|
+
id: z.ZodString;
|
|
7645
|
+
repo: z.ZodString;
|
|
7646
|
+
ready: z.ZodBoolean;
|
|
7647
|
+
waitsFor: z.ZodArray<z.ZodString>;
|
|
7648
|
+
sameRepo: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7649
|
+
why: z.ZodOptional<z.ZodString>;
|
|
7650
|
+
}, z.core.$strip>>;
|
|
7651
|
+
ready: z.ZodArray<z.ZodString>;
|
|
7652
|
+
repoOrder: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7653
|
+
}, z.core.$strip>;
|
|
7654
|
+
export type ReadyTasksT = z.infer<typeof ReadyTasks>;
|
|
7655
|
+
/**
|
|
7656
|
+
* 2.79.0 (ADR 0181 part 4): run the ready tasks one after another as one server job. The app never
|
|
7657
|
+
* asks for the pr level (that is the person's --approve, in an editor or on the command line), so
|
|
7658
|
+
* the click is the approval for draft; `tasks` names the ready ones the person saw.
|
|
7659
|
+
*/
|
|
7660
|
+
export declare const RunReadyRequest: z.ZodObject<{
|
|
7661
|
+
level: z.ZodOptional<z.ZodEnum<{
|
|
7662
|
+
draft: "draft";
|
|
7663
|
+
plan: "plan";
|
|
7664
|
+
}>>;
|
|
7665
|
+
runtime: z.ZodOptional<z.ZodEnum<{
|
|
7666
|
+
model: "model";
|
|
7667
|
+
"hand-off": "hand-off";
|
|
7668
|
+
"headless-claude-code": "headless-claude-code";
|
|
7669
|
+
"copilot-acp": "copilot-acp";
|
|
7670
|
+
mock: "mock";
|
|
7671
|
+
replay: "replay";
|
|
7672
|
+
}>>;
|
|
7673
|
+
tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7674
|
+
}, z.core.$strict>;
|
|
7675
|
+
export declare const RunReadyAccepted: z.ZodObject<{
|
|
7676
|
+
jobId: z.ZodString;
|
|
7677
|
+
tasks: z.ZodArray<z.ZodString>;
|
|
7678
|
+
}, z.core.$strip>;
|
|
7679
|
+
/** What the job's result says when it ends: each task run's state, and where it stopped and why. */
|
|
7680
|
+
export declare const RunReadyResult: z.ZodObject<{
|
|
7681
|
+
ran: z.ZodArray<z.ZodObject<{
|
|
7682
|
+
task: z.ZodString;
|
|
7683
|
+
repo: z.ZodString;
|
|
7684
|
+
state: z.ZodOptional<z.ZodString>;
|
|
7685
|
+
branch: z.ZodOptional<z.ZodString>;
|
|
7686
|
+
refused: z.ZodOptional<z.ZodString>;
|
|
7687
|
+
}, z.core.$strip>>;
|
|
7688
|
+
stopped: z.ZodOptional<z.ZodObject<{
|
|
7689
|
+
task: z.ZodString;
|
|
7690
|
+
why: z.ZodString;
|
|
7691
|
+
}, z.core.$strip>>;
|
|
7692
|
+
left: z.ZodArray<z.ZodString>;
|
|
7693
|
+
}, z.core.$strip>;
|
|
7694
|
+
export type RunReadyResultT = z.infer<typeof RunReadyResult>;
|
|
7695
|
+
/** ADR 0043, Release and Run screens: request bodies the CLI's uiRunRoutes parse. */
|
|
7696
|
+
export declare const StepDoneRequest: z.ZodObject<{
|
|
7697
|
+
values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
7698
|
+
skip: z.ZodOptional<z.ZodBoolean>;
|
|
7699
|
+
note: z.ZodOptional<z.ZodString>;
|
|
7700
|
+
change: z.ZodOptional<z.ZodString>;
|
|
7701
|
+
}, z.core.$strict>;
|
|
7702
|
+
export declare const StepRunRequest: z.ZodObject<{
|
|
7703
|
+
with: z.ZodString;
|
|
7704
|
+
inputsSha256: z.ZodString;
|
|
7705
|
+
fillOnly: z.ZodOptional<z.ZodBoolean>;
|
|
7706
|
+
change: z.ZodOptional<z.ZodString>;
|
|
7707
|
+
}, z.core.$strict>;
|
|
7708
|
+
export declare const ArchiveRequest: z.ZodObject<{
|
|
7709
|
+
rescan: z.ZodOptional<z.ZodBoolean>;
|
|
7710
|
+
}, z.core.$strict>;
|
|
7711
|
+
export declare const DraftRequestsRequest: z.ZodObject<{
|
|
7712
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
7713
|
+
}, z.core.$strict>;
|
|
7714
|
+
/** Round 36 (UX review): fill a draft's fields in snow.md from the app. */
|
|
7715
|
+
export declare const FillRequestFieldsRequest: z.ZodObject<{
|
|
7716
|
+
heading: z.ZodString;
|
|
7717
|
+
baseSha256: z.ZodString;
|
|
7718
|
+
values: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
7719
|
+
}, z.core.$strict>;
|
|
7720
|
+
export declare const FilledRequestFieldsView: z.ZodObject<{
|
|
7721
|
+
path: z.ZodString;
|
|
7722
|
+
sha256: z.ZodString;
|
|
7723
|
+
missing: z.ZodArray<z.ZodString>;
|
|
7724
|
+
lines: z.ZodArray<z.ZodString>;
|
|
7725
|
+
}, z.core.$strip>;
|
|
7726
|
+
export type FilledRequestFieldsView = z.infer<typeof FilledRequestFieldsView>;
|
|
7727
|
+
/** ADR 0045: record a measured outcome of a released change, as the signed-in person. */
|
|
7728
|
+
export declare const RecordOutcomeRequest: z.ZodObject<{
|
|
7729
|
+
measure: z.ZodString;
|
|
7730
|
+
value: z.ZodString;
|
|
7731
|
+
note: z.ZodOptional<z.ZodString>;
|
|
6452
7732
|
}, z.core.$strict>;
|
|
6453
7733
|
/** Live mode is part of the shape so the server can refuse it in words: it calls a real model. */
|
|
6454
7734
|
export declare const EvalRunRequest: z.ZodObject<{
|
|
@@ -6500,10 +7780,52 @@ export declare const TriageDecideRequest: z.ZodObject<{
|
|
|
6500
7780
|
export declare const ReconcileRequest: z.ZodObject<{
|
|
6501
7781
|
diagram: z.ZodString;
|
|
6502
7782
|
}, z.core.$strict>;
|
|
7783
|
+
/**
|
|
7784
|
+
* UX review: an initiative starts in the app, as `atticus initiative new` starts it; the
|
|
7785
|
+
* signed-in person is recorded as who started it.
|
|
7786
|
+
*/
|
|
7787
|
+
export declare const NewInitiativeRequest: z.ZodObject<{
|
|
7788
|
+
title: z.ZodString;
|
|
7789
|
+
journey: z.ZodEnum<{
|
|
7790
|
+
migration: "migration";
|
|
7791
|
+
"new-feature": "new-feature";
|
|
7792
|
+
"new-integration": "new-integration";
|
|
7793
|
+
"vendor-api-change": "vendor-api-change";
|
|
7794
|
+
"design-change": "design-change";
|
|
7795
|
+
"retire-system": "retire-system";
|
|
7796
|
+
}>;
|
|
7797
|
+
id: z.ZodOptional<z.ZodString>;
|
|
7798
|
+
release: z.ZodOptional<z.ZodISODate>;
|
|
7799
|
+
epic: z.ZodOptional<z.ZodString>;
|
|
7800
|
+
}, z.core.$strict>;
|
|
7801
|
+
/** UX review: plan an initiative's changes and commitments, as `atticus initiative plan` does. */
|
|
7802
|
+
export declare const InitiativePlanRequest: z.ZodObject<{
|
|
7803
|
+
target: z.ZodOptional<z.ZodString>;
|
|
7804
|
+
release: z.ZodOptional<z.ZodISODate>;
|
|
7805
|
+
systems: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7806
|
+
}, z.core.$strict>;
|
|
7807
|
+
/**
|
|
7808
|
+
* UX review: record where a commitment stands, as `atticus initiative commit` does, with an
|
|
7809
|
+
* optional note kept in the initiative's notes.yaml.
|
|
7810
|
+
*/
|
|
7811
|
+
export declare const CommitmentStatusRequest: z.ZodObject<{
|
|
7812
|
+
status: z.ZodEnum<{
|
|
7813
|
+
done: "done";
|
|
7814
|
+
open: "open";
|
|
7815
|
+
"at-risk": "at-risk";
|
|
7816
|
+
slipped: "slipped";
|
|
7817
|
+
}>;
|
|
7818
|
+
note: z.ZodOptional<z.ZodString>;
|
|
7819
|
+
}, z.core.$strict>;
|
|
7820
|
+
/** What a save of an initiative printed, and the initiative it was for. */
|
|
7821
|
+
export declare const InitiativeSavedView: z.ZodObject<{
|
|
7822
|
+
initiative: z.ZodString;
|
|
7823
|
+
lines: z.ZodArray<z.ZodString>;
|
|
7824
|
+
}, z.core.$strip>;
|
|
6503
7825
|
/** ADR 0078: the questions in questions/, and the files that aren't valid questions. */
|
|
6504
7826
|
export declare const QuestionList: z.ZodObject<{
|
|
6505
7827
|
questions: z.ZodArray<z.ZodObject<{
|
|
6506
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
|
|
7828
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
6507
7829
|
id: z.ZodString;
|
|
6508
7830
|
askedBy: z.ZodObject<{
|
|
6509
7831
|
step: z.ZodString;
|
|
@@ -6533,6 +7855,19 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6533
7855
|
}>;
|
|
6534
7856
|
id: z.ZodString;
|
|
6535
7857
|
}, z.core.$strict>;
|
|
7858
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
7859
|
+
product: "product";
|
|
7860
|
+
architecture: "architecture";
|
|
7861
|
+
delivery: "delivery";
|
|
7862
|
+
analysis: "analysis";
|
|
7863
|
+
}>>;
|
|
7864
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
7865
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
7866
|
+
change: z.ZodString;
|
|
7867
|
+
gate: z.ZodString;
|
|
7868
|
+
round: z.ZodNumber;
|
|
7869
|
+
id: z.ZodString;
|
|
7870
|
+
}, z.core.$strict>>;
|
|
6536
7871
|
state: z.ZodEnum<{
|
|
6537
7872
|
retired: "retired";
|
|
6538
7873
|
open: "open";
|
|
@@ -6542,7 +7877,19 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6542
7877
|
answer: z.ZodOptional<z.ZodObject<{
|
|
6543
7878
|
option: z.ZodOptional<z.ZodNumber>;
|
|
6544
7879
|
text: z.ZodOptional<z.ZodString>;
|
|
6545
|
-
by: z.ZodString
|
|
7880
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
7881
|
+
kind: z.ZodLiteral<"ai">;
|
|
7882
|
+
runtime: z.ZodEnum<{
|
|
7883
|
+
"hand-off": "hand-off";
|
|
7884
|
+
"copilot-acp": "copilot-acp";
|
|
7885
|
+
}>;
|
|
7886
|
+
run: z.ZodString;
|
|
7887
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
7888
|
+
confident: "confident";
|
|
7889
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
7890
|
+
"person-rule": "person-rule";
|
|
7891
|
+
}>>;
|
|
7892
|
+
}, z.core.$strict>]>;
|
|
6546
7893
|
at: z.ZodISODateTime;
|
|
6547
7894
|
scope: z.ZodObject<{
|
|
6548
7895
|
level: z.ZodEnum<{
|
|
@@ -6563,6 +7910,11 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6563
7910
|
quote: z.ZodString;
|
|
6564
7911
|
}, z.core.$strict>>;
|
|
6565
7912
|
}, z.core.$strict>>;
|
|
7913
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
7914
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
7915
|
+
from: z.ZodString;
|
|
7916
|
+
match: z.ZodString;
|
|
7917
|
+
}, z.core.$strict>>;
|
|
6566
7918
|
}, z.core.$strict>>;
|
|
6567
7919
|
retired: z.ZodOptional<z.ZodObject<{
|
|
6568
7920
|
at: z.ZodISODateTime;
|
|
@@ -6575,7 +7927,19 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6575
7927
|
answer: z.ZodObject<{
|
|
6576
7928
|
option: z.ZodOptional<z.ZodNumber>;
|
|
6577
7929
|
text: z.ZodOptional<z.ZodString>;
|
|
6578
|
-
by: z.ZodString
|
|
7930
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
7931
|
+
kind: z.ZodLiteral<"ai">;
|
|
7932
|
+
runtime: z.ZodEnum<{
|
|
7933
|
+
"hand-off": "hand-off";
|
|
7934
|
+
"copilot-acp": "copilot-acp";
|
|
7935
|
+
}>;
|
|
7936
|
+
run: z.ZodString;
|
|
7937
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
7938
|
+
confident: "confident";
|
|
7939
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
7940
|
+
"person-rule": "person-rule";
|
|
7941
|
+
}>>;
|
|
7942
|
+
}, z.core.$strict>]>;
|
|
6579
7943
|
at: z.ZodISODateTime;
|
|
6580
7944
|
scope: z.ZodObject<{
|
|
6581
7945
|
level: z.ZodEnum<{
|
|
@@ -6596,13 +7960,18 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6596
7960
|
quote: z.ZodString;
|
|
6597
7961
|
}, z.core.$strict>>;
|
|
6598
7962
|
}, z.core.$strict>>;
|
|
7963
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
7964
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
7965
|
+
from: z.ZodString;
|
|
7966
|
+
match: z.ZodString;
|
|
7967
|
+
}, z.core.$strict>>;
|
|
6599
7968
|
}, z.core.$strict>;
|
|
6600
7969
|
}, z.core.$strict>>;
|
|
6601
7970
|
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6602
7971
|
id: z.ZodString;
|
|
6603
7972
|
verdict: z.ZodEnum<{
|
|
6604
|
-
narrower: "narrower";
|
|
6605
7973
|
unsure: "unsure";
|
|
7974
|
+
narrower: "narrower";
|
|
6606
7975
|
}>;
|
|
6607
7976
|
judgment: z.ZodOptional<z.ZodString>;
|
|
6608
7977
|
}, z.core.$strict>>>;
|
|
@@ -6611,6 +7980,29 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6611
7980
|
file: z.ZodString;
|
|
6612
7981
|
message: z.ZodString;
|
|
6613
7982
|
}, z.core.$strip>>;
|
|
7983
|
+
counts: z.ZodOptional<z.ZodObject<{
|
|
7984
|
+
open: z.ZodNumber;
|
|
7985
|
+
answered: z.ZodNumber;
|
|
7986
|
+
retired: z.ZodNumber;
|
|
7987
|
+
total: z.ZodNumber;
|
|
7988
|
+
byRepo: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
7989
|
+
open: z.ZodNumber;
|
|
7990
|
+
answered: z.ZodNumber;
|
|
7991
|
+
retired: z.ZodNumber;
|
|
7992
|
+
total: z.ZodNumber;
|
|
7993
|
+
}, z.core.$strip>>>;
|
|
7994
|
+
byRole: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
|
|
7995
|
+
product: "product";
|
|
7996
|
+
architecture: "architecture";
|
|
7997
|
+
delivery: "delivery";
|
|
7998
|
+
analysis: "analysis";
|
|
7999
|
+
}> & z.core.$partial, z.ZodObject<{
|
|
8000
|
+
open: z.ZodNumber;
|
|
8001
|
+
answered: z.ZodNumber;
|
|
8002
|
+
retired: z.ZodNumber;
|
|
8003
|
+
total: z.ZodNumber;
|
|
8004
|
+
}, z.core.$strip>>>;
|
|
8005
|
+
}, z.core.$strip>>;
|
|
6614
8006
|
about: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
6615
8007
|
restsOn: z.ZodArray<z.ZodString>;
|
|
6616
8008
|
joins: z.ZodNumber;
|
|
@@ -6623,6 +8015,12 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6623
8015
|
}, z.core.$strip>, z.ZodObject<{
|
|
6624
8016
|
none: z.ZodString;
|
|
6625
8017
|
}, z.core.$strip>]>;
|
|
8018
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
8019
|
+
product: "product";
|
|
8020
|
+
architecture: "architecture";
|
|
8021
|
+
delivery: "delivery";
|
|
8022
|
+
analysis: "analysis";
|
|
8023
|
+
}>>;
|
|
6626
8024
|
proposal: z.ZodOptional<z.ZodObject<{
|
|
6627
8025
|
answer: z.ZodObject<{
|
|
6628
8026
|
option: z.ZodOptional<z.ZodNumber>;
|
|
@@ -6652,6 +8050,12 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
6652
8050
|
name: z.ZodOptional<z.ZodString>;
|
|
6653
8051
|
}, z.core.$strip>>;
|
|
6654
8052
|
}, z.core.$strip>>;
|
|
8053
|
+
yourRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
8054
|
+
product: "product";
|
|
8055
|
+
architecture: "architecture";
|
|
8056
|
+
delivery: "delivery";
|
|
8057
|
+
analysis: "analysis";
|
|
8058
|
+
}>>>;
|
|
6655
8059
|
}, z.core.$strip>;
|
|
6656
8060
|
export type QuestionListT = z.infer<typeof QuestionList>;
|
|
6657
8061
|
/** ADR 0078: answer a question with one of its options or in the person's own words. */
|
|
@@ -6675,7 +8079,7 @@ export declare const AnswerQuestionRequest: z.ZodObject<{
|
|
|
6675
8079
|
/** ADR 0078: the answered question, the command to run next and, for a repo type, its skill file. */
|
|
6676
8080
|
export declare const AnsweredQuestion: z.ZodObject<{
|
|
6677
8081
|
question: z.ZodObject<{
|
|
6678
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
|
|
8082
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
6679
8083
|
id: z.ZodString;
|
|
6680
8084
|
askedBy: z.ZodObject<{
|
|
6681
8085
|
step: z.ZodString;
|
|
@@ -6705,6 +8109,19 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
6705
8109
|
}>;
|
|
6706
8110
|
id: z.ZodString;
|
|
6707
8111
|
}, z.core.$strict>;
|
|
8112
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
8113
|
+
product: "product";
|
|
8114
|
+
architecture: "architecture";
|
|
8115
|
+
delivery: "delivery";
|
|
8116
|
+
analysis: "analysis";
|
|
8117
|
+
}>>;
|
|
8118
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
8119
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
8120
|
+
change: z.ZodString;
|
|
8121
|
+
gate: z.ZodString;
|
|
8122
|
+
round: z.ZodNumber;
|
|
8123
|
+
id: z.ZodString;
|
|
8124
|
+
}, z.core.$strict>>;
|
|
6708
8125
|
state: z.ZodEnum<{
|
|
6709
8126
|
retired: "retired";
|
|
6710
8127
|
open: "open";
|
|
@@ -6714,7 +8131,19 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
6714
8131
|
answer: z.ZodOptional<z.ZodObject<{
|
|
6715
8132
|
option: z.ZodOptional<z.ZodNumber>;
|
|
6716
8133
|
text: z.ZodOptional<z.ZodString>;
|
|
6717
|
-
by: z.ZodString
|
|
8134
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
8135
|
+
kind: z.ZodLiteral<"ai">;
|
|
8136
|
+
runtime: z.ZodEnum<{
|
|
8137
|
+
"hand-off": "hand-off";
|
|
8138
|
+
"copilot-acp": "copilot-acp";
|
|
8139
|
+
}>;
|
|
8140
|
+
run: z.ZodString;
|
|
8141
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
8142
|
+
confident: "confident";
|
|
8143
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
8144
|
+
"person-rule": "person-rule";
|
|
8145
|
+
}>>;
|
|
8146
|
+
}, z.core.$strict>]>;
|
|
6718
8147
|
at: z.ZodISODateTime;
|
|
6719
8148
|
scope: z.ZodObject<{
|
|
6720
8149
|
level: z.ZodEnum<{
|
|
@@ -6735,6 +8164,11 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
6735
8164
|
quote: z.ZodString;
|
|
6736
8165
|
}, z.core.$strict>>;
|
|
6737
8166
|
}, z.core.$strict>>;
|
|
8167
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
8168
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
8169
|
+
from: z.ZodString;
|
|
8170
|
+
match: z.ZodString;
|
|
8171
|
+
}, z.core.$strict>>;
|
|
6738
8172
|
}, z.core.$strict>>;
|
|
6739
8173
|
retired: z.ZodOptional<z.ZodObject<{
|
|
6740
8174
|
at: z.ZodISODateTime;
|
|
@@ -6747,7 +8181,19 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
6747
8181
|
answer: z.ZodObject<{
|
|
6748
8182
|
option: z.ZodOptional<z.ZodNumber>;
|
|
6749
8183
|
text: z.ZodOptional<z.ZodString>;
|
|
6750
|
-
by: z.ZodString
|
|
8184
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
8185
|
+
kind: z.ZodLiteral<"ai">;
|
|
8186
|
+
runtime: z.ZodEnum<{
|
|
8187
|
+
"hand-off": "hand-off";
|
|
8188
|
+
"copilot-acp": "copilot-acp";
|
|
8189
|
+
}>;
|
|
8190
|
+
run: z.ZodString;
|
|
8191
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
8192
|
+
confident: "confident";
|
|
8193
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
8194
|
+
"person-rule": "person-rule";
|
|
8195
|
+
}>>;
|
|
8196
|
+
}, z.core.$strict>]>;
|
|
6751
8197
|
at: z.ZodISODateTime;
|
|
6752
8198
|
scope: z.ZodObject<{
|
|
6753
8199
|
level: z.ZodEnum<{
|
|
@@ -6768,13 +8214,18 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
6768
8214
|
quote: z.ZodString;
|
|
6769
8215
|
}, z.core.$strict>>;
|
|
6770
8216
|
}, z.core.$strict>>;
|
|
8217
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
8218
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
8219
|
+
from: z.ZodString;
|
|
8220
|
+
match: z.ZodString;
|
|
8221
|
+
}, z.core.$strict>>;
|
|
6771
8222
|
}, z.core.$strict>;
|
|
6772
8223
|
}, z.core.$strict>>;
|
|
6773
8224
|
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6774
8225
|
id: z.ZodString;
|
|
6775
8226
|
verdict: z.ZodEnum<{
|
|
6776
|
-
narrower: "narrower";
|
|
6777
8227
|
unsure: "unsure";
|
|
8228
|
+
narrower: "narrower";
|
|
6778
8229
|
}>;
|
|
6779
8230
|
judgment: z.ZodOptional<z.ZodString>;
|
|
6780
8231
|
}, z.core.$strict>>>;
|
|
@@ -7663,8 +9114,8 @@ export declare const NeedView: z.ZodObject<{
|
|
|
7663
9114
|
"before-release": "before-release";
|
|
7664
9115
|
}>>;
|
|
7665
9116
|
from: z.ZodEnum<{
|
|
7666
|
-
stories: "stories";
|
|
7667
9117
|
assistant: "assistant";
|
|
9118
|
+
stories: "stories";
|
|
7668
9119
|
}>;
|
|
7669
9120
|
leadTime: z.ZodOptional<z.ZodString>;
|
|
7670
9121
|
handledBy: z.ZodOptional<z.ZodString>;
|
|
@@ -7736,8 +9187,8 @@ export declare const ChangeNeedsView: z.ZodObject<{
|
|
|
7736
9187
|
"before-release": "before-release";
|
|
7737
9188
|
}>>;
|
|
7738
9189
|
from: z.ZodEnum<{
|
|
7739
|
-
stories: "stories";
|
|
7740
9190
|
assistant: "assistant";
|
|
9191
|
+
stories: "stories";
|
|
7741
9192
|
}>;
|
|
7742
9193
|
leadTime: z.ZodOptional<z.ZodString>;
|
|
7743
9194
|
handledBy: z.ZodOptional<z.ZodString>;
|
|
@@ -7822,8 +9273,8 @@ export declare const MarkedNeed: z.ZodObject<{
|
|
|
7822
9273
|
"before-release": "before-release";
|
|
7823
9274
|
}>>;
|
|
7824
9275
|
from: z.ZodEnum<{
|
|
7825
|
-
stories: "stories";
|
|
7826
9276
|
assistant: "assistant";
|
|
9277
|
+
stories: "stories";
|
|
7827
9278
|
}>;
|
|
7828
9279
|
leadTime: z.ZodOptional<z.ZodString>;
|
|
7829
9280
|
handledBy: z.ZodOptional<z.ZodString>;
|
|
@@ -7964,40 +9415,1278 @@ export type AcceptedOrgPackT = z.infer<typeof AcceptedOrgPack>;
|
|
|
7964
9415
|
export type MarkedNeedT = z.infer<typeof MarkedNeed>;
|
|
7965
9416
|
export type ReviewedItemT = z.infer<typeof ReviewedItem>;
|
|
7966
9417
|
export type KeptCandidateT = z.infer<typeof KeptCandidate>;
|
|
7967
|
-
/**
|
|
7968
|
-
export declare const
|
|
7969
|
-
|
|
9418
|
+
/** The other box of a connection: a repo of the manifest, or an outside system of the profile. */
|
|
9419
|
+
export declare const LinkBox: z.ZodObject<{
|
|
9420
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
9421
|
+
system: z.ZodOptional<z.ZodString>;
|
|
9422
|
+
}, z.core.$strict>;
|
|
9423
|
+
export declare const CandidateSuggestion: z.ZodObject<{
|
|
9424
|
+
api: z.ZodString;
|
|
9425
|
+
score: z.ZodNumber;
|
|
9426
|
+
why: z.ZodEnum<{
|
|
9427
|
+
"same-path": "same-path";
|
|
9428
|
+
prefix: "prefix";
|
|
9429
|
+
parameter: "parameter";
|
|
9430
|
+
"names-alike": "names-alike";
|
|
9431
|
+
setting: "setting";
|
|
9432
|
+
"operation-words": "operation-words";
|
|
9433
|
+
"forwarded-path": "forwarded-path";
|
|
9434
|
+
}>;
|
|
9435
|
+
}, z.core.$strip>;
|
|
9436
|
+
export declare const CandidateCallView: z.ZodObject<{
|
|
9437
|
+
fact: z.ZodString;
|
|
9438
|
+
callType: z.ZodString;
|
|
9439
|
+
method: z.ZodOptional<z.ZodString>;
|
|
7970
9440
|
path: z.ZodString;
|
|
7971
|
-
|
|
7972
|
-
|
|
7973
|
-
|
|
7974
|
-
|
|
7975
|
-
|
|
7976
|
-
|
|
7977
|
-
|
|
7978
|
-
|
|
7979
|
-
|
|
9441
|
+
at: z.ZodString;
|
|
9442
|
+
status: z.ZodEnum<{
|
|
9443
|
+
asked: "asked";
|
|
9444
|
+
paired: "paired";
|
|
9445
|
+
outside: "outside";
|
|
9446
|
+
left: "left";
|
|
9447
|
+
missed: "missed";
|
|
9448
|
+
unresolved: "unresolved";
|
|
9449
|
+
}>;
|
|
9450
|
+
why: z.ZodOptional<z.ZodString>;
|
|
9451
|
+
paired: z.ZodOptional<z.ZodString>;
|
|
9452
|
+
suggestion: z.ZodOptional<z.ZodObject<{
|
|
9453
|
+
api: z.ZodString;
|
|
9454
|
+
score: z.ZodNumber;
|
|
9455
|
+
why: z.ZodEnum<{
|
|
9456
|
+
"same-path": "same-path";
|
|
9457
|
+
prefix: "prefix";
|
|
9458
|
+
parameter: "parameter";
|
|
9459
|
+
"names-alike": "names-alike";
|
|
9460
|
+
setting: "setting";
|
|
9461
|
+
"operation-words": "operation-words";
|
|
9462
|
+
"forwarded-path": "forwarded-path";
|
|
9463
|
+
}>;
|
|
9464
|
+
}, z.core.$strip>>;
|
|
9465
|
+
suggestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
9466
|
+
api: z.ZodString;
|
|
9467
|
+
score: z.ZodNumber;
|
|
9468
|
+
why: z.ZodEnum<{
|
|
9469
|
+
"same-path": "same-path";
|
|
9470
|
+
prefix: "prefix";
|
|
9471
|
+
parameter: "parameter";
|
|
9472
|
+
"names-alike": "names-alike";
|
|
9473
|
+
setting: "setting";
|
|
9474
|
+
"operation-words": "operation-words";
|
|
9475
|
+
"forwarded-path": "forwarded-path";
|
|
9476
|
+
}>;
|
|
9477
|
+
}, z.core.$strip>>>;
|
|
9478
|
+
confident: z.ZodOptional<z.ZodBoolean>;
|
|
9479
|
+
}, z.core.$strip>;
|
|
9480
|
+
export declare const CandidateApiView: z.ZodObject<{
|
|
9481
|
+
id: z.ZodString;
|
|
9482
|
+
kind: z.ZodEnum<{
|
|
9483
|
+
route: "route";
|
|
9484
|
+
entry: "entry";
|
|
9485
|
+
operation: "operation";
|
|
9486
|
+
}>;
|
|
9487
|
+
method: z.ZodOptional<z.ZodString>;
|
|
9488
|
+
path: z.ZodString;
|
|
9489
|
+
at: z.ZodOptional<z.ZodString>;
|
|
9490
|
+
words: z.ZodOptional<z.ZodString>;
|
|
9491
|
+
forwards: z.ZodOptional<z.ZodString>;
|
|
9492
|
+
}, z.core.$strip>;
|
|
9493
|
+
export declare const LinkCandidatesView: z.ZodObject<{
|
|
9494
|
+
from: z.ZodString;
|
|
9495
|
+
to: z.ZodObject<{
|
|
9496
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
9497
|
+
system: z.ZodOptional<z.ZodString>;
|
|
9498
|
+
}, z.core.$strict>;
|
|
9499
|
+
toName: z.ZodString;
|
|
9500
|
+
calls: z.ZodArray<z.ZodObject<{
|
|
9501
|
+
fact: z.ZodString;
|
|
9502
|
+
callType: z.ZodString;
|
|
9503
|
+
method: z.ZodOptional<z.ZodString>;
|
|
9504
|
+
path: z.ZodString;
|
|
9505
|
+
at: z.ZodString;
|
|
9506
|
+
status: z.ZodEnum<{
|
|
9507
|
+
asked: "asked";
|
|
9508
|
+
paired: "paired";
|
|
9509
|
+
outside: "outside";
|
|
9510
|
+
left: "left";
|
|
9511
|
+
missed: "missed";
|
|
9512
|
+
unresolved: "unresolved";
|
|
9513
|
+
}>;
|
|
9514
|
+
why: z.ZodOptional<z.ZodString>;
|
|
9515
|
+
paired: z.ZodOptional<z.ZodString>;
|
|
9516
|
+
suggestion: z.ZodOptional<z.ZodObject<{
|
|
9517
|
+
api: z.ZodString;
|
|
9518
|
+
score: z.ZodNumber;
|
|
9519
|
+
why: z.ZodEnum<{
|
|
9520
|
+
"same-path": "same-path";
|
|
9521
|
+
prefix: "prefix";
|
|
9522
|
+
parameter: "parameter";
|
|
9523
|
+
"names-alike": "names-alike";
|
|
9524
|
+
setting: "setting";
|
|
9525
|
+
"operation-words": "operation-words";
|
|
9526
|
+
"forwarded-path": "forwarded-path";
|
|
9527
|
+
}>;
|
|
9528
|
+
}, z.core.$strip>>;
|
|
9529
|
+
suggestions: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
9530
|
+
api: z.ZodString;
|
|
9531
|
+
score: z.ZodNumber;
|
|
9532
|
+
why: z.ZodEnum<{
|
|
9533
|
+
"same-path": "same-path";
|
|
9534
|
+
prefix: "prefix";
|
|
9535
|
+
parameter: "parameter";
|
|
9536
|
+
"names-alike": "names-alike";
|
|
9537
|
+
setting: "setting";
|
|
9538
|
+
"operation-words": "operation-words";
|
|
9539
|
+
"forwarded-path": "forwarded-path";
|
|
9540
|
+
}>;
|
|
9541
|
+
}, z.core.$strip>>>;
|
|
9542
|
+
confident: z.ZodOptional<z.ZodBoolean>;
|
|
9543
|
+
}, z.core.$strip>>;
|
|
9544
|
+
apis: z.ZodArray<z.ZodObject<{
|
|
9545
|
+
id: z.ZodString;
|
|
9546
|
+
kind: z.ZodEnum<{
|
|
9547
|
+
route: "route";
|
|
9548
|
+
entry: "entry";
|
|
9549
|
+
operation: "operation";
|
|
9550
|
+
}>;
|
|
9551
|
+
method: z.ZodOptional<z.ZodString>;
|
|
9552
|
+
path: z.ZodString;
|
|
9553
|
+
at: z.ZodOptional<z.ZodString>;
|
|
9554
|
+
words: z.ZodOptional<z.ZodString>;
|
|
9555
|
+
forwards: z.ZodOptional<z.ZodString>;
|
|
9556
|
+
}, z.core.$strip>>;
|
|
9557
|
+
noCalls: z.ZodOptional<z.ZodObject<{
|
|
9558
|
+
command: z.ZodString;
|
|
9559
|
+
why: z.ZodOptional<z.ZodEnum<{
|
|
9560
|
+
unverified: "unverified";
|
|
9561
|
+
}>>;
|
|
9562
|
+
}, z.core.$strip>>;
|
|
9563
|
+
noApis: z.ZodOptional<z.ZodObject<{
|
|
9564
|
+
why: z.ZodEnum<{
|
|
9565
|
+
"not-read": "not-read";
|
|
9566
|
+
unverified: "unverified";
|
|
9567
|
+
"no-spec": "no-spec";
|
|
9568
|
+
}>;
|
|
9569
|
+
command: z.ZodString;
|
|
9570
|
+
}, z.core.$strip>>;
|
|
9571
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
9572
|
+
question: z.ZodString;
|
|
9573
|
+
calls: z.ZodNumber;
|
|
9574
|
+
}, z.core.$strip>>;
|
|
9575
|
+
}, z.core.$strip>;
|
|
9576
|
+
/** ADR 0178 part 2: Copilot matches A's loose calls with B's APIs; a person ticks the proposals. */
|
|
9577
|
+
export declare const MatchLinksRequest: z.ZodObject<{
|
|
9578
|
+
from: z.ZodString;
|
|
9579
|
+
to: z.ZodObject<{
|
|
9580
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
9581
|
+
system: z.ZodOptional<z.ZodString>;
|
|
9582
|
+
}, z.core.$strict>;
|
|
9583
|
+
}, z.core.$strip>;
|
|
9584
|
+
export declare const MatchProposal: z.ZodObject<{
|
|
9585
|
+
call: z.ZodString;
|
|
9586
|
+
api: z.ZodString;
|
|
9587
|
+
why: z.ZodString;
|
|
9588
|
+
lines: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
9589
|
+
}, z.core.$strip>;
|
|
9590
|
+
export declare const MatchLinksView: z.ZodObject<{
|
|
9591
|
+
from: z.ZodString;
|
|
9592
|
+
to: z.ZodObject<{
|
|
9593
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
9594
|
+
system: z.ZodOptional<z.ZodString>;
|
|
9595
|
+
}, z.core.$strict>;
|
|
7980
9596
|
state: z.ZodEnum<{
|
|
7981
9597
|
done: "done";
|
|
7982
9598
|
failed: "failed";
|
|
7983
|
-
cancelled: "cancelled";
|
|
7984
9599
|
running: "running";
|
|
7985
|
-
|
|
7986
|
-
|
|
7987
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
7988
|
-
type: z.ZodLiteral<"index.rebuilt">;
|
|
7989
|
-
records: z.ZodNumber;
|
|
7990
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
7991
|
-
type: z.ZodLiteral<"run.changed">;
|
|
7992
|
-
runId: z.ZodString;
|
|
7993
|
-
state: z.ZodEnum<{
|
|
7994
|
-
failed: "failed";
|
|
7995
|
-
prepared: "prepared";
|
|
7996
|
-
waiting: "waiting";
|
|
7997
|
-
produced: "produced";
|
|
7998
|
-
validated: "validated";
|
|
7999
|
-
cancelled: "cancelled";
|
|
9600
|
+
handoff: "handoff";
|
|
9601
|
+
idle: "idle";
|
|
8000
9602
|
}>;
|
|
9603
|
+
brief: z.ZodOptional<z.ZodString>;
|
|
9604
|
+
answer: z.ZodOptional<z.ZodString>;
|
|
9605
|
+
jobId: z.ZodOptional<z.ZodString>;
|
|
9606
|
+
proposals: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
9607
|
+
call: z.ZodString;
|
|
9608
|
+
api: z.ZodString;
|
|
9609
|
+
why: z.ZodString;
|
|
9610
|
+
lines: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
9611
|
+
}, z.core.$strip>>>;
|
|
9612
|
+
none: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
9613
|
+
call: z.ZodString;
|
|
9614
|
+
why: z.ZodString;
|
|
9615
|
+
}, z.core.$strip>>>;
|
|
9616
|
+
rejected: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
9617
|
+
error: z.ZodOptional<z.ZodString>;
|
|
9618
|
+
run: z.ZodOptional<z.ZodString>;
|
|
9619
|
+
decided: z.ZodOptional<z.ZodObject<{
|
|
9620
|
+
mode: z.ZodEnum<{
|
|
9621
|
+
auto: "auto";
|
|
9622
|
+
propose: "propose";
|
|
9623
|
+
}>;
|
|
9624
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
9625
|
+
applied: z.ZodArray<z.ZodObject<{
|
|
9626
|
+
call: z.ZodString;
|
|
9627
|
+
api: z.ZodString;
|
|
9628
|
+
bar: z.ZodEnum<{
|
|
9629
|
+
confident: "confident";
|
|
9630
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
9631
|
+
"person-rule": "person-rule";
|
|
9632
|
+
}>;
|
|
9633
|
+
}, z.core.$strip>>;
|
|
9634
|
+
kept: z.ZodArray<z.ZodObject<{
|
|
9635
|
+
call: z.ZodString;
|
|
9636
|
+
api: z.ZodString;
|
|
9637
|
+
why: z.ZodString;
|
|
9638
|
+
}, z.core.$strip>>;
|
|
9639
|
+
paused: z.ZodOptional<z.ZodString>;
|
|
9640
|
+
}, z.core.$strip>>;
|
|
9641
|
+
}, z.core.$strip>;
|
|
9642
|
+
/** How many links or questions were settled each way: from code, by a person, by AI. */
|
|
9643
|
+
export declare const DecisionCounts: z.ZodObject<{
|
|
9644
|
+
fromCode: z.ZodNumber;
|
|
9645
|
+
byPerson: z.ZodNumber;
|
|
9646
|
+
byAi: z.ZodNumber;
|
|
9647
|
+
open: z.ZodOptional<z.ZodNumber>;
|
|
9648
|
+
retired: z.ZodOptional<z.ZodNumber>;
|
|
9649
|
+
}, z.core.$strip>;
|
|
9650
|
+
/** One decision the AI applied that still stands: what every "Detected by AI" chip shows. */
|
|
9651
|
+
export declare const AiDecisionItem: z.ZodObject<{
|
|
9652
|
+
kind: z.ZodEnum<{
|
|
9653
|
+
link: "link";
|
|
9654
|
+
question: "question";
|
|
9655
|
+
}>;
|
|
9656
|
+
item: z.ZodString;
|
|
9657
|
+
repo: z.ZodString;
|
|
9658
|
+
what: z.ZodString;
|
|
9659
|
+
decided: z.ZodString;
|
|
9660
|
+
call: z.ZodOptional<z.ZodObject<{
|
|
9661
|
+
fact: z.ZodString;
|
|
9662
|
+
file: z.ZodString;
|
|
9663
|
+
line: z.ZodNumber;
|
|
9664
|
+
value: z.ZodString;
|
|
9665
|
+
}, z.core.$strip>>;
|
|
9666
|
+
to: z.ZodOptional<z.ZodObject<{
|
|
9667
|
+
repo: z.ZodString;
|
|
9668
|
+
entry: z.ZodOptional<z.ZodString>;
|
|
9669
|
+
method: z.ZodOptional<z.ZodString>;
|
|
9670
|
+
path: z.ZodString;
|
|
9671
|
+
}, z.core.$strip>>;
|
|
9672
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
9673
|
+
text: z.ZodString;
|
|
9674
|
+
option: z.ZodNumber;
|
|
9675
|
+
options: z.ZodArray<z.ZodString>;
|
|
9676
|
+
}, z.core.$strip>>;
|
|
9677
|
+
runtime: z.ZodString;
|
|
9678
|
+
run: z.ZodString;
|
|
9679
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
9680
|
+
confident: "confident";
|
|
9681
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
9682
|
+
"person-rule": "person-rule";
|
|
9683
|
+
}>>;
|
|
9684
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
9685
|
+
at: z.ZodString;
|
|
9686
|
+
cites: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
9687
|
+
}, z.core.$strip>;
|
|
9688
|
+
/** A batch of decisions applied at once, one Undo away. */
|
|
9689
|
+
export declare const DecisionBatchView: z.ZodObject<{
|
|
9690
|
+
id: z.ZodString;
|
|
9691
|
+
kind: z.ZodEnum<{
|
|
9692
|
+
ai: "ai";
|
|
9693
|
+
rule: "rule";
|
|
9694
|
+
}>;
|
|
9695
|
+
at: z.ZodString;
|
|
9696
|
+
by: z.ZodString;
|
|
9697
|
+
run: z.ZodOptional<z.ZodString>;
|
|
9698
|
+
applied: z.ZodNumber;
|
|
9699
|
+
reverted: z.ZodNumber;
|
|
9700
|
+
correction: z.ZodOptional<z.ZodObject<{
|
|
9701
|
+
item: z.ZodString;
|
|
9702
|
+
answer: z.ZodString;
|
|
9703
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
9704
|
+
kind: z.ZodEnum<{
|
|
9705
|
+
path: "path";
|
|
9706
|
+
host: "host";
|
|
9707
|
+
topic: "topic";
|
|
9708
|
+
}>;
|
|
9709
|
+
match: z.ZodString;
|
|
9710
|
+
from: z.ZodString;
|
|
9711
|
+
}, z.core.$strip>>;
|
|
9712
|
+
}, z.core.$strip>>;
|
|
9713
|
+
undone: z.ZodOptional<z.ZodObject<{
|
|
9714
|
+
by: z.ZodString;
|
|
9715
|
+
at: z.ZodString;
|
|
9716
|
+
}, z.core.$strip>>;
|
|
9717
|
+
file: z.ZodString;
|
|
9718
|
+
}, z.core.$strip>;
|
|
9719
|
+
/** Whether the AI decides now, as runtime.yaml says and the sample audit allows (Home). */
|
|
9720
|
+
export declare const DecideStateView: z.ZodObject<{
|
|
9721
|
+
configured: z.ZodObject<{
|
|
9722
|
+
links: z.ZodEnum<{
|
|
9723
|
+
auto: "auto";
|
|
9724
|
+
propose: "propose";
|
|
9725
|
+
}>;
|
|
9726
|
+
questions: z.ZodEnum<{
|
|
9727
|
+
auto: "auto";
|
|
9728
|
+
propose: "propose";
|
|
9729
|
+
}>;
|
|
9730
|
+
minPrecision: z.ZodNumber;
|
|
9731
|
+
}, z.core.$strip>;
|
|
9732
|
+
now: z.ZodObject<{
|
|
9733
|
+
links: z.ZodEnum<{
|
|
9734
|
+
auto: "auto";
|
|
9735
|
+
propose: "propose";
|
|
9736
|
+
}>;
|
|
9737
|
+
questions: z.ZodEnum<{
|
|
9738
|
+
auto: "auto";
|
|
9739
|
+
propose: "propose";
|
|
9740
|
+
}>;
|
|
9741
|
+
}, z.core.$strip>;
|
|
9742
|
+
paused: z.ZodOptional<z.ZodObject<{
|
|
9743
|
+
why: z.ZodString;
|
|
9744
|
+
precision: z.ZodNumber;
|
|
9745
|
+
low: z.ZodNullable<z.ZodNumber>;
|
|
9746
|
+
high: z.ZodNullable<z.ZodNumber>;
|
|
9747
|
+
answered: z.ZodNumber;
|
|
9748
|
+
minPrecision: z.ZodNumber;
|
|
9749
|
+
}, z.core.$strip>>;
|
|
9750
|
+
precision: z.ZodObject<{
|
|
9751
|
+
drawn: z.ZodNumber;
|
|
9752
|
+
right: z.ZodNumber;
|
|
9753
|
+
wrong: z.ZodNumber;
|
|
9754
|
+
unsure: z.ZodNumber;
|
|
9755
|
+
open: z.ZodNumber;
|
|
9756
|
+
gone: z.ZodNumber;
|
|
9757
|
+
precision: z.ZodNullable<z.ZodNumber>;
|
|
9758
|
+
low: z.ZodNullable<z.ZodNumber>;
|
|
9759
|
+
high: z.ZodNullable<z.ZodNumber>;
|
|
9760
|
+
}, z.core.$strip>;
|
|
9761
|
+
decideIn: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
9762
|
+
"hand-off": "hand-off";
|
|
9763
|
+
"copilot-acp": "copilot-acp";
|
|
9764
|
+
}>>>;
|
|
9765
|
+
}, z.core.$strip>;
|
|
9766
|
+
/** GET /api/decisions: the AI's decisions, the counts split three ways, the batches, the pause. */
|
|
9767
|
+
export declare const DecisionsView: z.ZodObject<{
|
|
9768
|
+
decide: z.ZodObject<{
|
|
9769
|
+
configured: z.ZodObject<{
|
|
9770
|
+
links: z.ZodEnum<{
|
|
9771
|
+
auto: "auto";
|
|
9772
|
+
propose: "propose";
|
|
9773
|
+
}>;
|
|
9774
|
+
questions: z.ZodEnum<{
|
|
9775
|
+
auto: "auto";
|
|
9776
|
+
propose: "propose";
|
|
9777
|
+
}>;
|
|
9778
|
+
minPrecision: z.ZodNumber;
|
|
9779
|
+
}, z.core.$strip>;
|
|
9780
|
+
now: z.ZodObject<{
|
|
9781
|
+
links: z.ZodEnum<{
|
|
9782
|
+
auto: "auto";
|
|
9783
|
+
propose: "propose";
|
|
9784
|
+
}>;
|
|
9785
|
+
questions: z.ZodEnum<{
|
|
9786
|
+
auto: "auto";
|
|
9787
|
+
propose: "propose";
|
|
9788
|
+
}>;
|
|
9789
|
+
}, z.core.$strip>;
|
|
9790
|
+
paused: z.ZodOptional<z.ZodObject<{
|
|
9791
|
+
why: z.ZodString;
|
|
9792
|
+
precision: z.ZodNumber;
|
|
9793
|
+
low: z.ZodNullable<z.ZodNumber>;
|
|
9794
|
+
high: z.ZodNullable<z.ZodNumber>;
|
|
9795
|
+
answered: z.ZodNumber;
|
|
9796
|
+
minPrecision: z.ZodNumber;
|
|
9797
|
+
}, z.core.$strip>>;
|
|
9798
|
+
precision: z.ZodObject<{
|
|
9799
|
+
drawn: z.ZodNumber;
|
|
9800
|
+
right: z.ZodNumber;
|
|
9801
|
+
wrong: z.ZodNumber;
|
|
9802
|
+
unsure: z.ZodNumber;
|
|
9803
|
+
open: z.ZodNumber;
|
|
9804
|
+
gone: z.ZodNumber;
|
|
9805
|
+
precision: z.ZodNullable<z.ZodNumber>;
|
|
9806
|
+
low: z.ZodNullable<z.ZodNumber>;
|
|
9807
|
+
high: z.ZodNullable<z.ZodNumber>;
|
|
9808
|
+
}, z.core.$strip>;
|
|
9809
|
+
decideIn: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
9810
|
+
"hand-off": "hand-off";
|
|
9811
|
+
"copilot-acp": "copilot-acp";
|
|
9812
|
+
}>>>;
|
|
9813
|
+
}, z.core.$strip>;
|
|
9814
|
+
links: z.ZodObject<{
|
|
9815
|
+
counts: z.ZodObject<{
|
|
9816
|
+
fromCode: z.ZodNumber;
|
|
9817
|
+
byPerson: z.ZodNumber;
|
|
9818
|
+
byAi: z.ZodNumber;
|
|
9819
|
+
open: z.ZodOptional<z.ZodNumber>;
|
|
9820
|
+
retired: z.ZodOptional<z.ZodNumber>;
|
|
9821
|
+
}, z.core.$strip>;
|
|
9822
|
+
items: z.ZodArray<z.ZodObject<{
|
|
9823
|
+
kind: z.ZodEnum<{
|
|
9824
|
+
link: "link";
|
|
9825
|
+
question: "question";
|
|
9826
|
+
}>;
|
|
9827
|
+
item: z.ZodString;
|
|
9828
|
+
repo: z.ZodString;
|
|
9829
|
+
what: z.ZodString;
|
|
9830
|
+
decided: z.ZodString;
|
|
9831
|
+
call: z.ZodOptional<z.ZodObject<{
|
|
9832
|
+
fact: z.ZodString;
|
|
9833
|
+
file: z.ZodString;
|
|
9834
|
+
line: z.ZodNumber;
|
|
9835
|
+
value: z.ZodString;
|
|
9836
|
+
}, z.core.$strip>>;
|
|
9837
|
+
to: z.ZodOptional<z.ZodObject<{
|
|
9838
|
+
repo: z.ZodString;
|
|
9839
|
+
entry: z.ZodOptional<z.ZodString>;
|
|
9840
|
+
method: z.ZodOptional<z.ZodString>;
|
|
9841
|
+
path: z.ZodString;
|
|
9842
|
+
}, z.core.$strip>>;
|
|
9843
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
9844
|
+
text: z.ZodString;
|
|
9845
|
+
option: z.ZodNumber;
|
|
9846
|
+
options: z.ZodArray<z.ZodString>;
|
|
9847
|
+
}, z.core.$strip>>;
|
|
9848
|
+
runtime: z.ZodString;
|
|
9849
|
+
run: z.ZodString;
|
|
9850
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
9851
|
+
confident: "confident";
|
|
9852
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
9853
|
+
"person-rule": "person-rule";
|
|
9854
|
+
}>>;
|
|
9855
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
9856
|
+
at: z.ZodString;
|
|
9857
|
+
cites: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
9858
|
+
}, z.core.$strip>>;
|
|
9859
|
+
lines: z.ZodOptional<z.ZodObject<{
|
|
9860
|
+
byAi: z.ZodNumber;
|
|
9861
|
+
byPerson: z.ZodNumber;
|
|
9862
|
+
}, z.core.$strip>>;
|
|
9863
|
+
}, z.core.$strip>;
|
|
9864
|
+
questions: z.ZodObject<{
|
|
9865
|
+
counts: z.ZodObject<{
|
|
9866
|
+
fromCode: z.ZodNumber;
|
|
9867
|
+
byPerson: z.ZodNumber;
|
|
9868
|
+
byAi: z.ZodNumber;
|
|
9869
|
+
open: z.ZodOptional<z.ZodNumber>;
|
|
9870
|
+
retired: z.ZodOptional<z.ZodNumber>;
|
|
9871
|
+
}, z.core.$strip>;
|
|
9872
|
+
items: z.ZodArray<z.ZodObject<{
|
|
9873
|
+
kind: z.ZodEnum<{
|
|
9874
|
+
link: "link";
|
|
9875
|
+
question: "question";
|
|
9876
|
+
}>;
|
|
9877
|
+
item: z.ZodString;
|
|
9878
|
+
repo: z.ZodString;
|
|
9879
|
+
what: z.ZodString;
|
|
9880
|
+
decided: z.ZodString;
|
|
9881
|
+
call: z.ZodOptional<z.ZodObject<{
|
|
9882
|
+
fact: z.ZodString;
|
|
9883
|
+
file: z.ZodString;
|
|
9884
|
+
line: z.ZodNumber;
|
|
9885
|
+
value: z.ZodString;
|
|
9886
|
+
}, z.core.$strip>>;
|
|
9887
|
+
to: z.ZodOptional<z.ZodObject<{
|
|
9888
|
+
repo: z.ZodString;
|
|
9889
|
+
entry: z.ZodOptional<z.ZodString>;
|
|
9890
|
+
method: z.ZodOptional<z.ZodString>;
|
|
9891
|
+
path: z.ZodString;
|
|
9892
|
+
}, z.core.$strip>>;
|
|
9893
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
9894
|
+
text: z.ZodString;
|
|
9895
|
+
option: z.ZodNumber;
|
|
9896
|
+
options: z.ZodArray<z.ZodString>;
|
|
9897
|
+
}, z.core.$strip>>;
|
|
9898
|
+
runtime: z.ZodString;
|
|
9899
|
+
run: z.ZodString;
|
|
9900
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
9901
|
+
confident: "confident";
|
|
9902
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
9903
|
+
"person-rule": "person-rule";
|
|
9904
|
+
}>>;
|
|
9905
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
9906
|
+
at: z.ZodString;
|
|
9907
|
+
cites: z.ZodDefault<z.ZodArray<z.ZodString>>;
|
|
9908
|
+
}, z.core.$strip>>;
|
|
9909
|
+
}, z.core.$strip>;
|
|
9910
|
+
batches: z.ZodArray<z.ZodObject<{
|
|
9911
|
+
id: z.ZodString;
|
|
9912
|
+
kind: z.ZodEnum<{
|
|
9913
|
+
ai: "ai";
|
|
9914
|
+
rule: "rule";
|
|
9915
|
+
}>;
|
|
9916
|
+
at: z.ZodString;
|
|
9917
|
+
by: z.ZodString;
|
|
9918
|
+
run: z.ZodOptional<z.ZodString>;
|
|
9919
|
+
applied: z.ZodNumber;
|
|
9920
|
+
reverted: z.ZodNumber;
|
|
9921
|
+
correction: z.ZodOptional<z.ZodObject<{
|
|
9922
|
+
item: z.ZodString;
|
|
9923
|
+
answer: z.ZodString;
|
|
9924
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
9925
|
+
kind: z.ZodEnum<{
|
|
9926
|
+
path: "path";
|
|
9927
|
+
host: "host";
|
|
9928
|
+
topic: "topic";
|
|
9929
|
+
}>;
|
|
9930
|
+
match: z.ZodString;
|
|
9931
|
+
from: z.ZodString;
|
|
9932
|
+
}, z.core.$strip>>;
|
|
9933
|
+
}, z.core.$strip>>;
|
|
9934
|
+
undone: z.ZodOptional<z.ZodObject<{
|
|
9935
|
+
by: z.ZodString;
|
|
9936
|
+
at: z.ZodString;
|
|
9937
|
+
}, z.core.$strip>>;
|
|
9938
|
+
file: z.ZodString;
|
|
9939
|
+
}, z.core.$strip>>;
|
|
9940
|
+
problems: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
9941
|
+
file: z.ZodString;
|
|
9942
|
+
message: z.ZodString;
|
|
9943
|
+
}, z.core.$strip>>>;
|
|
9944
|
+
}, z.core.$strip>;
|
|
9945
|
+
export declare const CorrectDecisionRequest: z.ZodObject<{
|
|
9946
|
+
item: z.ZodString;
|
|
9947
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
9948
|
+
api: z.ZodOptional<z.ZodString>;
|
|
9949
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
9950
|
+
none: z.ZodOptional<z.ZodBoolean>;
|
|
9951
|
+
similar: z.ZodOptional<z.ZodBoolean>;
|
|
9952
|
+
match: z.ZodOptional<z.ZodString>;
|
|
9953
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
9954
|
+
}, z.core.$strip>;
|
|
9955
|
+
/** One item a correction's rule re-checked, and what became of it. */
|
|
9956
|
+
export declare const SpreadItemView: z.ZodObject<{
|
|
9957
|
+
item: z.ZodString;
|
|
9958
|
+
repo: z.ZodString;
|
|
9959
|
+
what: z.ZodString;
|
|
9960
|
+
was: z.ZodOptional<z.ZodString>;
|
|
9961
|
+
now: z.ZodOptional<z.ZodString>;
|
|
9962
|
+
change: z.ZodEnum<{
|
|
9963
|
+
confirmed: "confirmed";
|
|
9964
|
+
applied: "applied";
|
|
9965
|
+
reverted: "reverted";
|
|
9966
|
+
replaced: "replaced";
|
|
9967
|
+
}>;
|
|
9968
|
+
}, z.core.$strip>;
|
|
9969
|
+
export declare const CorrectDecisionResult: z.ZodObject<{
|
|
9970
|
+
written: z.ZodBoolean;
|
|
9971
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
9972
|
+
item: z.ZodString;
|
|
9973
|
+
answer: z.ZodString;
|
|
9974
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
9975
|
+
kind: z.ZodEnum<{
|
|
9976
|
+
path: "path";
|
|
9977
|
+
host: "host";
|
|
9978
|
+
topic: "topic";
|
|
9979
|
+
}>;
|
|
9980
|
+
match: z.ZodString;
|
|
9981
|
+
derived: z.ZodBoolean;
|
|
9982
|
+
}, z.core.$strip>>;
|
|
9983
|
+
noRule: z.ZodOptional<z.ZodString>;
|
|
9984
|
+
spread: z.ZodArray<z.ZodObject<{
|
|
9985
|
+
item: z.ZodString;
|
|
9986
|
+
repo: z.ZodString;
|
|
9987
|
+
what: z.ZodString;
|
|
9988
|
+
was: z.ZodOptional<z.ZodString>;
|
|
9989
|
+
now: z.ZodOptional<z.ZodString>;
|
|
9990
|
+
change: z.ZodEnum<{
|
|
9991
|
+
confirmed: "confirmed";
|
|
9992
|
+
applied: "applied";
|
|
9993
|
+
reverted: "reverted";
|
|
9994
|
+
replaced: "replaced";
|
|
9995
|
+
}>;
|
|
9996
|
+
}, z.core.$strip>>;
|
|
9997
|
+
counts: z.ZodObject<{
|
|
9998
|
+
applied: z.ZodNumber;
|
|
9999
|
+
confirmed: z.ZodNumber;
|
|
10000
|
+
replaced: z.ZodNumber;
|
|
10001
|
+
reverted: z.ZodNumber;
|
|
10002
|
+
}, z.core.$strip>;
|
|
10003
|
+
makeRule: z.ZodOptional<z.ZodObject<{
|
|
10004
|
+
corrections: z.ZodNumber;
|
|
10005
|
+
shape: z.ZodString;
|
|
10006
|
+
repo: z.ZodString;
|
|
10007
|
+
line: z.ZodOptional<z.ZodString>;
|
|
10008
|
+
command: z.ZodOptional<z.ZodString>;
|
|
10009
|
+
}, z.core.$strip>>;
|
|
10010
|
+
files: z.ZodArray<z.ZodString>;
|
|
10011
|
+
verify: z.ZodArray<z.ZodString>;
|
|
10012
|
+
commit: z.ZodString;
|
|
10013
|
+
}, z.core.$strip>;
|
|
10014
|
+
export declare const UndoBatchResult: z.ZodObject<{
|
|
10015
|
+
batch: z.ZodString;
|
|
10016
|
+
removed: z.ZodNumber;
|
|
10017
|
+
restored: z.ZodNumber;
|
|
10018
|
+
skipped: z.ZodArray<z.ZodString>;
|
|
10019
|
+
files: z.ZodArray<z.ZodString>;
|
|
10020
|
+
verify: z.ZodArray<z.ZodString>;
|
|
10021
|
+
commit: z.ZodString;
|
|
10022
|
+
}, z.core.$strip>;
|
|
10023
|
+
/**
|
|
10024
|
+
* 2.84.0 (ADR 0181, ninth UX walk): Ask AI to propose answers as a hand-off run. The person's
|
|
10025
|
+
* assistant writes the proposals; Done (POST /api/runs/{runId}/done) reads them in and decides
|
|
10026
|
+
* from them as the AI's when runtime.yaml's decide.questions is auto, else keeps them as proposals.
|
|
10027
|
+
*/
|
|
10028
|
+
export declare const QuestionsProposeView: z.ZodObject<{
|
|
10029
|
+
state: z.ZodEnum<{
|
|
10030
|
+
none: "none";
|
|
10031
|
+
waiting: "waiting";
|
|
10032
|
+
}>;
|
|
10033
|
+
run: z.ZodOptional<z.ZodString>;
|
|
10034
|
+
line: z.ZodString;
|
|
10035
|
+
prompt: z.ZodOptional<z.ZodString>;
|
|
10036
|
+
done: z.ZodOptional<z.ZodString>;
|
|
10037
|
+
}, z.core.$strip>;
|
|
10038
|
+
/** 2.84.0: GET /api/upgrade: the upgrade steps this metarepo waits on (atticus upgrade --check). */
|
|
10039
|
+
export declare const UpgradeView: z.ZodObject<{
|
|
10040
|
+
atticus: z.ZodString;
|
|
10041
|
+
newer: z.ZodBoolean;
|
|
10042
|
+
stamp: z.ZodOptional<z.ZodString>;
|
|
10043
|
+
pending: z.ZodArray<z.ZodObject<{
|
|
10044
|
+
id: z.ZodString;
|
|
10045
|
+
summary: z.ZodString;
|
|
10046
|
+
files: z.ZodArray<z.ZodString>;
|
|
10047
|
+
}, z.core.$strip>>;
|
|
10048
|
+
}, z.core.$strip>;
|
|
10049
|
+
export declare const ConnectLinksRequest: z.ZodObject<{
|
|
10050
|
+
from: z.ZodString;
|
|
10051
|
+
to: z.ZodObject<{
|
|
10052
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
10053
|
+
system: z.ZodOptional<z.ZodString>;
|
|
10054
|
+
}, z.core.$strict>;
|
|
10055
|
+
pairs: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
10056
|
+
call: z.ZodString;
|
|
10057
|
+
api: z.ZodString;
|
|
10058
|
+
}, z.core.$strip>>>;
|
|
10059
|
+
rule: z.ZodOptional<z.ZodBoolean>;
|
|
10060
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
10061
|
+
}, z.core.$strip>;
|
|
10062
|
+
export declare const ConnectLinksResult: z.ZodObject<{
|
|
10063
|
+
written: z.ZodBoolean;
|
|
10064
|
+
file: z.ZodString;
|
|
10065
|
+
lines: z.ZodArray<z.ZodString>;
|
|
10066
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
10067
|
+
question: z.ZodString;
|
|
10068
|
+
match: z.ZodString;
|
|
10069
|
+
target: z.ZodString;
|
|
10070
|
+
}, z.core.$strip>>;
|
|
10071
|
+
preview: z.ZodOptional<z.ZodUnknown>;
|
|
10072
|
+
verify: z.ZodString;
|
|
10073
|
+
commit: z.ZodString;
|
|
10074
|
+
}, z.core.$strip>;
|
|
10075
|
+
export declare const UndoCorrectionRequest: z.ZodObject<{
|
|
10076
|
+
line: z.ZodString;
|
|
10077
|
+
}, z.core.$strip>;
|
|
10078
|
+
export declare const LineChangeView: z.ZodObject<{
|
|
10079
|
+
was: z.ZodOptional<z.ZodString>;
|
|
10080
|
+
now: z.ZodOptional<z.ZodString>;
|
|
10081
|
+
}, z.core.$strip>;
|
|
10082
|
+
/** G2: a repo's owner and system, and what each can be set to. */
|
|
10083
|
+
export declare const RepoOwnerView: z.ZodObject<{
|
|
10084
|
+
repo: z.ZodString;
|
|
10085
|
+
owner: z.ZodString;
|
|
10086
|
+
system: z.ZodOptional<z.ZodString>;
|
|
10087
|
+
file: z.ZodString;
|
|
10088
|
+
teams: z.ZodArray<z.ZodObject<{
|
|
10089
|
+
id: z.ZodString;
|
|
10090
|
+
name: z.ZodString;
|
|
10091
|
+
}, z.core.$strip>>;
|
|
10092
|
+
systems: z.ZodArray<z.ZodObject<{
|
|
10093
|
+
id: z.ZodString;
|
|
10094
|
+
name: z.ZodString;
|
|
10095
|
+
}, z.core.$strip>>;
|
|
10096
|
+
}, z.core.$strip>;
|
|
10097
|
+
export declare const SetRepoOwnerRequest: z.ZodObject<{
|
|
10098
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
10099
|
+
system: z.ZodOptional<z.ZodString>;
|
|
10100
|
+
addTeam: z.ZodOptional<z.ZodObject<{
|
|
10101
|
+
id: z.ZodString;
|
|
10102
|
+
name: z.ZodString;
|
|
10103
|
+
}, z.core.$strip>>;
|
|
10104
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
10105
|
+
}, z.core.$strip>;
|
|
10106
|
+
export declare const SetRepoOwnerResult: z.ZodObject<{
|
|
10107
|
+
written: z.ZodBoolean;
|
|
10108
|
+
files: z.ZodArray<z.ZodObject<{
|
|
10109
|
+
file: z.ZodString;
|
|
10110
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
10111
|
+
was: z.ZodOptional<z.ZodString>;
|
|
10112
|
+
now: z.ZodOptional<z.ZodString>;
|
|
10113
|
+
}, z.core.$strip>>;
|
|
10114
|
+
}, z.core.$strip>>;
|
|
10115
|
+
verify: z.ZodString;
|
|
10116
|
+
commit: z.ZodString;
|
|
10117
|
+
}, z.core.$strip>;
|
|
10118
|
+
/** G3: a link the code can't show, declared on the canvas. */
|
|
10119
|
+
export declare const DeclareLinkRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
10120
|
+
kind: z.ZodLiteral<"topic">;
|
|
10121
|
+
system: z.ZodString;
|
|
10122
|
+
topic: z.ZodString;
|
|
10123
|
+
side: z.ZodEnum<{
|
|
10124
|
+
publishes: "publishes";
|
|
10125
|
+
listens: "listens";
|
|
10126
|
+
}>;
|
|
10127
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
10128
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10129
|
+
kind: z.ZodLiteral<"call">;
|
|
10130
|
+
system: z.ZodString;
|
|
10131
|
+
route: z.ZodString;
|
|
10132
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
10133
|
+
}, z.core.$strip>], "kind">;
|
|
10134
|
+
export declare const FileChangeResult: z.ZodObject<{
|
|
10135
|
+
written: z.ZodBoolean;
|
|
10136
|
+
files: z.ZodArray<z.ZodObject<{
|
|
10137
|
+
file: z.ZodString;
|
|
10138
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
10139
|
+
was: z.ZodOptional<z.ZodString>;
|
|
10140
|
+
now: z.ZodOptional<z.ZodString>;
|
|
10141
|
+
}, z.core.$strip>>;
|
|
10142
|
+
}, z.core.$strip>>;
|
|
10143
|
+
verify: z.ZodString;
|
|
10144
|
+
commit: z.ZodString;
|
|
10145
|
+
}, z.core.$strip>;
|
|
10146
|
+
/**
|
|
10147
|
+
* ADR 0179: a stroke drawn on the canvas for a change (a call, a topic, a table, a step removed
|
|
10148
|
+
* or sent elsewhere, one taken back), checked in full by the planner's Stroke schema.
|
|
10149
|
+
*/
|
|
10150
|
+
export declare const SketchStrokeRequest: z.ZodObject<{
|
|
10151
|
+
stroke: z.ZodObject<{
|
|
10152
|
+
kind: z.ZodEnum<{
|
|
10153
|
+
table: "table";
|
|
10154
|
+
call: "call";
|
|
10155
|
+
topic: "topic";
|
|
10156
|
+
remove: "remove";
|
|
10157
|
+
retarget: "retarget";
|
|
10158
|
+
undo: "undo";
|
|
10159
|
+
}>;
|
|
10160
|
+
}, z.core.$loose>;
|
|
10161
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
10162
|
+
expect: z.ZodOptional<z.ZodString>;
|
|
10163
|
+
}, z.core.$strip>;
|
|
10164
|
+
export declare const SketchResult: z.ZodObject<{
|
|
10165
|
+
written: z.ZodBoolean;
|
|
10166
|
+
files: z.ZodArray<z.ZodObject<{
|
|
10167
|
+
file: z.ZodString;
|
|
10168
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
10169
|
+
was: z.ZodOptional<z.ZodString>;
|
|
10170
|
+
now: z.ZodOptional<z.ZodString>;
|
|
10171
|
+
}, z.core.$strip>>;
|
|
10172
|
+
}, z.core.$strip>>;
|
|
10173
|
+
problem: z.ZodOptional<z.ZodString>;
|
|
10174
|
+
pick: z.ZodOptional<z.ZodObject<{
|
|
10175
|
+
flows: z.ZodArray<z.ZodObject<{
|
|
10176
|
+
id: z.ZodString;
|
|
10177
|
+
name: z.ZodString;
|
|
10178
|
+
}, z.core.$strip>>;
|
|
10179
|
+
}, z.core.$strip>>;
|
|
10180
|
+
map: z.ZodOptional<z.ZodObject<{
|
|
10181
|
+
change: z.ZodString;
|
|
10182
|
+
title: z.ZodString;
|
|
10183
|
+
source: z.ZodString;
|
|
10184
|
+
groups: z.ZodArray<z.ZodObject<{
|
|
10185
|
+
id: z.ZodString;
|
|
10186
|
+
label: z.ZodString;
|
|
10187
|
+
kind: z.ZodEnum<{
|
|
10188
|
+
system: "system";
|
|
10189
|
+
datastore: "datastore";
|
|
10190
|
+
}>;
|
|
10191
|
+
boundary: z.ZodOptional<z.ZodEnum<{
|
|
10192
|
+
product: "product";
|
|
10193
|
+
internal: "internal";
|
|
10194
|
+
vendor: "vendor";
|
|
10195
|
+
}>>;
|
|
10196
|
+
legend: z.ZodOptional<z.ZodEnum<{
|
|
10197
|
+
new: "new";
|
|
10198
|
+
modify: "modify";
|
|
10199
|
+
retire: "retire";
|
|
10200
|
+
}>>;
|
|
10201
|
+
}, z.core.$strip>>;
|
|
10202
|
+
nodes: z.ZodArray<z.ZodObject<{
|
|
10203
|
+
id: z.ZodString;
|
|
10204
|
+
label: z.ZodString;
|
|
10205
|
+
kind: z.ZodEnum<{
|
|
10206
|
+
system: "system";
|
|
10207
|
+
component: "component";
|
|
10208
|
+
table: "table";
|
|
10209
|
+
topic: "topic";
|
|
10210
|
+
box: "box";
|
|
10211
|
+
}>;
|
|
10212
|
+
boundary: z.ZodOptional<z.ZodEnum<{
|
|
10213
|
+
product: "product";
|
|
10214
|
+
internal: "internal";
|
|
10215
|
+
vendor: "vendor";
|
|
10216
|
+
}>>;
|
|
10217
|
+
legend: z.ZodOptional<z.ZodEnum<{
|
|
10218
|
+
new: "new";
|
|
10219
|
+
modify: "modify";
|
|
10220
|
+
retire: "retire";
|
|
10221
|
+
}>>;
|
|
10222
|
+
group: z.ZodOptional<z.ZodString>;
|
|
10223
|
+
}, z.core.$strip>>;
|
|
10224
|
+
edges: z.ZodArray<z.ZodObject<{
|
|
10225
|
+
id: z.ZodString;
|
|
10226
|
+
from: z.ZodString;
|
|
10227
|
+
to: z.ZodString;
|
|
10228
|
+
label: z.ZodString;
|
|
10229
|
+
async: z.ZodBoolean;
|
|
10230
|
+
legend: z.ZodOptional<z.ZodEnum<{
|
|
10231
|
+
new: "new";
|
|
10232
|
+
modify: "modify";
|
|
10233
|
+
retire: "retire";
|
|
10234
|
+
}>>;
|
|
10235
|
+
}, z.core.$strip>>;
|
|
10236
|
+
mermaid: z.ZodString;
|
|
10237
|
+
flows: z.ZodNumber;
|
|
10238
|
+
problems: z.ZodArray<z.ZodString>;
|
|
10239
|
+
}, z.core.$strip>>;
|
|
10240
|
+
drawn: z.ZodArray<z.ZodObject<{
|
|
10241
|
+
flow: z.ZodString;
|
|
10242
|
+
index: z.ZodNumber;
|
|
10243
|
+
what: z.ZodString;
|
|
10244
|
+
by: z.ZodOptional<z.ZodString>;
|
|
10245
|
+
}, z.core.$strip>>;
|
|
10246
|
+
commit: z.ZodString;
|
|
10247
|
+
fingerprint: z.ZodOptional<z.ZodString>;
|
|
10248
|
+
}, z.core.$strip>;
|
|
10249
|
+
export declare const UndeclareLinkRequest: z.ZodObject<{
|
|
10250
|
+
kind: z.ZodEnum<{
|
|
10251
|
+
call: "call";
|
|
10252
|
+
topic: "topic";
|
|
10253
|
+
}>;
|
|
10254
|
+
system: z.ZodString;
|
|
10255
|
+
value: z.ZodString;
|
|
10256
|
+
}, z.core.$strip>;
|
|
10257
|
+
/** G3: what can be added to the picture: repos (read or not), systems and teams. */
|
|
10258
|
+
/** ADR 0180: a component type as the app shows it (the org pack's shape, plus its source and notes). */
|
|
10259
|
+
export declare const ComponentTypeView: z.ZodObject<{
|
|
10260
|
+
id: z.ZodString;
|
|
10261
|
+
name: z.ZodString;
|
|
10262
|
+
description: z.ZodString;
|
|
10263
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
10264
|
+
source: z.ZodEnum<{
|
|
10265
|
+
"org-pack": "org-pack";
|
|
10266
|
+
builtin: "builtin";
|
|
10267
|
+
}>;
|
|
10268
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
10269
|
+
kind: z.ZodString;
|
|
10270
|
+
value: z.ZodString;
|
|
10271
|
+
why: z.ZodOptional<z.ZodString>;
|
|
10272
|
+
}, z.core.$strip>>;
|
|
10273
|
+
runsOn: z.ZodOptional<z.ZodObject<{
|
|
10274
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
10275
|
+
cloud: z.ZodOptional<z.ZodString>;
|
|
10276
|
+
framework: z.ZodOptional<z.ZodString>;
|
|
10277
|
+
}, z.core.$strip>>;
|
|
10278
|
+
draws: z.ZodOptional<z.ZodObject<{
|
|
10279
|
+
shape: z.ZodOptional<z.ZodString>;
|
|
10280
|
+
colour: z.ZodOptional<z.ZodString>;
|
|
10281
|
+
badge: z.ZodOptional<z.ZodString>;
|
|
10282
|
+
}, z.core.$strip>>;
|
|
10283
|
+
must: z.ZodArray<z.ZodString>;
|
|
10284
|
+
mustNot: z.ZodArray<z.ZodString>;
|
|
10285
|
+
notes: z.ZodOptional<z.ZodString>;
|
|
10286
|
+
file: z.ZodOptional<z.ZodString>;
|
|
10287
|
+
}, z.core.$strip>;
|
|
10288
|
+
export declare const ComponentTypesView: z.ZodObject<{
|
|
10289
|
+
types: z.ZodArray<z.ZodObject<{
|
|
10290
|
+
id: z.ZodString;
|
|
10291
|
+
name: z.ZodString;
|
|
10292
|
+
description: z.ZodString;
|
|
10293
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
10294
|
+
source: z.ZodEnum<{
|
|
10295
|
+
"org-pack": "org-pack";
|
|
10296
|
+
builtin: "builtin";
|
|
10297
|
+
}>;
|
|
10298
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
10299
|
+
kind: z.ZodString;
|
|
10300
|
+
value: z.ZodString;
|
|
10301
|
+
why: z.ZodOptional<z.ZodString>;
|
|
10302
|
+
}, z.core.$strip>>;
|
|
10303
|
+
runsOn: z.ZodOptional<z.ZodObject<{
|
|
10304
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
10305
|
+
cloud: z.ZodOptional<z.ZodString>;
|
|
10306
|
+
framework: z.ZodOptional<z.ZodString>;
|
|
10307
|
+
}, z.core.$strip>>;
|
|
10308
|
+
draws: z.ZodOptional<z.ZodObject<{
|
|
10309
|
+
shape: z.ZodOptional<z.ZodString>;
|
|
10310
|
+
colour: z.ZodOptional<z.ZodString>;
|
|
10311
|
+
badge: z.ZodOptional<z.ZodString>;
|
|
10312
|
+
}, z.core.$strip>>;
|
|
10313
|
+
must: z.ZodArray<z.ZodString>;
|
|
10314
|
+
mustNot: z.ZodArray<z.ZodString>;
|
|
10315
|
+
notes: z.ZodOptional<z.ZodString>;
|
|
10316
|
+
file: z.ZodOptional<z.ZodString>;
|
|
10317
|
+
}, z.core.$strip>>;
|
|
10318
|
+
folder: z.ZodString;
|
|
10319
|
+
}, z.core.$strip>;
|
|
10320
|
+
export declare const AddableView: z.ZodObject<{
|
|
10321
|
+
repos: z.ZodArray<z.ZodObject<{
|
|
10322
|
+
id: z.ZodString;
|
|
10323
|
+
name: z.ZodString;
|
|
10324
|
+
read: z.ZodBoolean;
|
|
10325
|
+
}, z.core.$strip>>;
|
|
10326
|
+
systems: z.ZodArray<z.ZodObject<{
|
|
10327
|
+
id: z.ZodString;
|
|
10328
|
+
name: z.ZodString;
|
|
10329
|
+
boundary: z.ZodOptional<z.ZodString>;
|
|
10330
|
+
}, z.core.$strip>>;
|
|
10331
|
+
teams: z.ZodArray<z.ZodObject<{
|
|
10332
|
+
id: z.ZodString;
|
|
10333
|
+
name: z.ZodString;
|
|
10334
|
+
}, z.core.$strip>>;
|
|
10335
|
+
}, z.core.$strip>;
|
|
10336
|
+
export declare const AddSystemRequest: z.ZodObject<{
|
|
10337
|
+
id: z.ZodString;
|
|
10338
|
+
name: z.ZodString;
|
|
10339
|
+
boundary: z.ZodEnum<{
|
|
10340
|
+
internal: "internal";
|
|
10341
|
+
vendor: "vendor";
|
|
10342
|
+
}>;
|
|
10343
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
10344
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
10345
|
+
}, z.core.$strip>;
|
|
10346
|
+
/** G3: a box's corrections and declarations, each with what undoes it. */
|
|
10347
|
+
export declare const BoxCorrections: z.ZodObject<{
|
|
10348
|
+
items: z.ZodArray<z.ZodObject<{
|
|
10349
|
+
kind: z.ZodEnum<{
|
|
10350
|
+
link: "link";
|
|
10351
|
+
call: "call";
|
|
10352
|
+
wrong: "wrong";
|
|
10353
|
+
topic: "topic";
|
|
10354
|
+
edit: "edit";
|
|
10355
|
+
unlink: "unlink";
|
|
10356
|
+
}>;
|
|
10357
|
+
says: z.ZodString;
|
|
10358
|
+
by: z.ZodOptional<z.ZodString>;
|
|
10359
|
+
ai: z.ZodOptional<z.ZodObject<{
|
|
10360
|
+
runtime: z.ZodString;
|
|
10361
|
+
run: z.ZodString;
|
|
10362
|
+
}, z.core.$strip>>;
|
|
10363
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
10364
|
+
at: z.ZodOptional<z.ZodString>;
|
|
10365
|
+
file: z.ZodString;
|
|
10366
|
+
undo: z.ZodUnion<readonly [z.ZodObject<{
|
|
10367
|
+
repo: z.ZodString;
|
|
10368
|
+
line: z.ZodString;
|
|
10369
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10370
|
+
kind: z.ZodEnum<{
|
|
10371
|
+
call: "call";
|
|
10372
|
+
topic: "topic";
|
|
10373
|
+
}>;
|
|
10374
|
+
system: z.ZodString;
|
|
10375
|
+
value: z.ZodString;
|
|
10376
|
+
}, z.core.$strip>]>;
|
|
10377
|
+
stale: z.ZodOptional<z.ZodBoolean>;
|
|
10378
|
+
}, z.core.$strip>>;
|
|
10379
|
+
}, z.core.$strip>;
|
|
10380
|
+
/** G6 (ADR 0175): a canvas's named filters and layers, kept in the metarepo for review. */
|
|
10381
|
+
export declare const SavedCanvasView: z.ZodObject<{
|
|
10382
|
+
name: z.ZodString;
|
|
10383
|
+
lens: z.ZodString;
|
|
10384
|
+
node: z.ZodString;
|
|
10385
|
+
filter: z.ZodDefault<z.ZodString>;
|
|
10386
|
+
layers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
|
|
10387
|
+
overlay: z.ZodDefault<z.ZodEnum<{
|
|
10388
|
+
none: "none";
|
|
10389
|
+
questions: "questions";
|
|
10390
|
+
gaps: "gaps";
|
|
10391
|
+
}>>;
|
|
10392
|
+
mismatches: z.ZodDefault<z.ZodBoolean>;
|
|
10393
|
+
by: z.ZodOptional<z.ZodString>;
|
|
10394
|
+
at: z.ZodOptional<z.ZodString>;
|
|
10395
|
+
}, z.core.$strip>;
|
|
10396
|
+
export declare const SavedCanvasViews: z.ZodObject<{
|
|
10397
|
+
views: z.ZodArray<z.ZodObject<{
|
|
10398
|
+
name: z.ZodString;
|
|
10399
|
+
lens: z.ZodString;
|
|
10400
|
+
node: z.ZodString;
|
|
10401
|
+
filter: z.ZodDefault<z.ZodString>;
|
|
10402
|
+
layers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
|
|
10403
|
+
overlay: z.ZodDefault<z.ZodEnum<{
|
|
10404
|
+
none: "none";
|
|
10405
|
+
questions: "questions";
|
|
10406
|
+
gaps: "gaps";
|
|
10407
|
+
}>>;
|
|
10408
|
+
mismatches: z.ZodDefault<z.ZodBoolean>;
|
|
10409
|
+
by: z.ZodOptional<z.ZodString>;
|
|
10410
|
+
at: z.ZodOptional<z.ZodString>;
|
|
10411
|
+
}, z.core.$strip>>;
|
|
10412
|
+
dir: z.ZodString;
|
|
10413
|
+
}, z.core.$strip>;
|
|
10414
|
+
/** G6: a cited line, as a file to open in an editor. */
|
|
10415
|
+
export declare const CodeLink: z.ZodObject<{
|
|
10416
|
+
path: z.ZodOptional<z.ZodString>;
|
|
10417
|
+
line: z.ZodNumber;
|
|
10418
|
+
vscode: z.ZodOptional<z.ZodString>;
|
|
10419
|
+
idea: z.ZodOptional<z.ZodString>;
|
|
10420
|
+
missing: z.ZodOptional<z.ZodString>;
|
|
10421
|
+
}, z.core.$strip>;
|
|
10422
|
+
export type SavedCanvasViewT = z.infer<typeof SavedCanvasView>;
|
|
10423
|
+
export type SavedCanvasViewsT = z.infer<typeof SavedCanvasViews>;
|
|
10424
|
+
export type CodeLinkT = z.infer<typeof CodeLink>;
|
|
10425
|
+
/** G4 from the canvas (ADR 0176): a draft reading rule for a repo's type, from a pairing. */
|
|
10426
|
+
export declare const RuleFromPairingRequest: z.ZodObject<{
|
|
10427
|
+
repo: z.ZodString;
|
|
10428
|
+
line: z.ZodString;
|
|
10429
|
+
}, z.core.$strip>;
|
|
10430
|
+
export declare const RuleFromPairingResult: z.ZodObject<{
|
|
10431
|
+
file: z.ZodString;
|
|
10432
|
+
key: z.ZodString;
|
|
10433
|
+
rule: z.ZodString;
|
|
10434
|
+
activate: z.ZodString;
|
|
10435
|
+
}, z.core.$strip>;
|
|
10436
|
+
export type RuleFromPairingResultT = z.infer<typeof RuleFromPairingResult>;
|
|
10437
|
+
export type DeclareLinkRequestT = z.infer<typeof DeclareLinkRequest>;
|
|
10438
|
+
export type FileChangeResultT = z.infer<typeof FileChangeResult>;
|
|
10439
|
+
export type SketchStrokeRequestT = z.infer<typeof SketchStrokeRequest>;
|
|
10440
|
+
export type SketchResultT = z.infer<typeof SketchResult>;
|
|
10441
|
+
export type AddableViewT = z.infer<typeof AddableView>;
|
|
10442
|
+
export type ComponentTypeViewT = z.infer<typeof ComponentTypeView>;
|
|
10443
|
+
export type ComponentTypesViewT = z.infer<typeof ComponentTypesView>;
|
|
10444
|
+
export type AddSystemRequestT = z.infer<typeof AddSystemRequest>;
|
|
10445
|
+
export type BoxCorrectionsT = z.infer<typeof BoxCorrections>;
|
|
10446
|
+
export type RepoOwnerViewT = z.infer<typeof RepoOwnerView>;
|
|
10447
|
+
export type SetRepoOwnerRequestT = z.infer<typeof SetRepoOwnerRequest>;
|
|
10448
|
+
export type SetRepoOwnerResultT = z.infer<typeof SetRepoOwnerResult>;
|
|
10449
|
+
export type LinkBoxT = z.infer<typeof LinkBox>;
|
|
10450
|
+
export type CandidateCallViewT = z.infer<typeof CandidateCallView>;
|
|
10451
|
+
export type CandidateApiViewT = z.infer<typeof CandidateApiView>;
|
|
10452
|
+
export type LinkCandidatesViewT = z.infer<typeof LinkCandidatesView>;
|
|
10453
|
+
export type ConnectLinksRequestT = z.infer<typeof ConnectLinksRequest>;
|
|
10454
|
+
export type ConnectLinksResultT = z.infer<typeof ConnectLinksResult>;
|
|
10455
|
+
export type MatchLinksRequestT = z.infer<typeof MatchLinksRequest>;
|
|
10456
|
+
export type MatchLinksViewT = z.infer<typeof MatchLinksView>;
|
|
10457
|
+
export type MatchProposalT = z.infer<typeof MatchProposal>;
|
|
10458
|
+
export type DecisionCountsT = z.infer<typeof DecisionCounts>;
|
|
10459
|
+
export type AiDecisionItemT = z.infer<typeof AiDecisionItem>;
|
|
10460
|
+
export type DecisionBatchViewT = z.infer<typeof DecisionBatchView>;
|
|
10461
|
+
export type DecideStateViewT = z.infer<typeof DecideStateView>;
|
|
10462
|
+
export type DecisionsViewT = z.infer<typeof DecisionsView>;
|
|
10463
|
+
export type CorrectDecisionRequestT = z.infer<typeof CorrectDecisionRequest>;
|
|
10464
|
+
export type SpreadItemViewT = z.infer<typeof SpreadItemView>;
|
|
10465
|
+
export type CorrectDecisionResultT = z.infer<typeof CorrectDecisionResult>;
|
|
10466
|
+
export type UndoBatchResultT = z.infer<typeof UndoBatchResult>;
|
|
10467
|
+
export type QuestionsProposeViewT = z.infer<typeof QuestionsProposeView>;
|
|
10468
|
+
export type UpgradeViewT = z.infer<typeof UpgradeView>;
|
|
10469
|
+
/** What an unattended Copilot run started from the app reads. */
|
|
10470
|
+
export declare const CopilotRunKind: z.ZodEnum<{
|
|
10471
|
+
repos: "repos";
|
|
10472
|
+
stale: "stale";
|
|
10473
|
+
gaps: "gaps";
|
|
10474
|
+
all: "all";
|
|
10475
|
+
}>;
|
|
10476
|
+
export declare const StartCopilotRunRequest: z.ZodObject<{
|
|
10477
|
+
kind: z.ZodEnum<{
|
|
10478
|
+
repos: "repos";
|
|
10479
|
+
stale: "stale";
|
|
10480
|
+
gaps: "gaps";
|
|
10481
|
+
all: "all";
|
|
10482
|
+
}>;
|
|
10483
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10484
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
10485
|
+
}, z.core.$strip>;
|
|
10486
|
+
export declare const CopilotRunState: z.ZodEnum<{
|
|
10487
|
+
done: "done";
|
|
10488
|
+
failed: "failed";
|
|
10489
|
+
running: "running";
|
|
10490
|
+
stopped: "stopped";
|
|
10491
|
+
}>;
|
|
10492
|
+
export declare const CopilotRunTab: z.ZodObject<{
|
|
10493
|
+
id: z.ZodString;
|
|
10494
|
+
title: z.ZodString;
|
|
10495
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
10496
|
+
state: z.ZodEnum<{
|
|
10497
|
+
failed: "failed";
|
|
10498
|
+
running: "running";
|
|
10499
|
+
ended: "ended";
|
|
10500
|
+
}>;
|
|
10501
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
10502
|
+
from: z.ZodNumber;
|
|
10503
|
+
lines: z.ZodArray<z.ZodString>;
|
|
10504
|
+
}, z.core.$strip>;
|
|
10505
|
+
export declare const CopilotRunView: z.ZodObject<{
|
|
10506
|
+
runId: z.ZodString;
|
|
10507
|
+
jobId: z.ZodString;
|
|
10508
|
+
kind: z.ZodEnum<{
|
|
10509
|
+
repos: "repos";
|
|
10510
|
+
stale: "stale";
|
|
10511
|
+
gaps: "gaps";
|
|
10512
|
+
all: "all";
|
|
10513
|
+
}>;
|
|
10514
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10515
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
10516
|
+
state: z.ZodEnum<{
|
|
10517
|
+
done: "done";
|
|
10518
|
+
failed: "failed";
|
|
10519
|
+
running: "running";
|
|
10520
|
+
stopped: "stopped";
|
|
10521
|
+
}>;
|
|
10522
|
+
by: z.ZodOptional<z.ZodString>;
|
|
10523
|
+
startedAt: z.ZodString;
|
|
10524
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
10525
|
+
model: z.ZodOptional<z.ZodString>;
|
|
10526
|
+
progress: z.ZodObject<{
|
|
10527
|
+
repos: z.ZodNumber;
|
|
10528
|
+
repoIndex: z.ZodNumber;
|
|
10529
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
10530
|
+
session: z.ZodOptional<z.ZodString>;
|
|
10531
|
+
sessions: z.ZodNumber;
|
|
10532
|
+
}, z.core.$strip>;
|
|
10533
|
+
totals: z.ZodObject<{
|
|
10534
|
+
kept: z.ZodNumber;
|
|
10535
|
+
rejected: z.ZodNumber;
|
|
10536
|
+
tokens: z.ZodNumber;
|
|
10537
|
+
}, z.core.$strip>;
|
|
10538
|
+
message: z.ZodOptional<z.ZodString>;
|
|
10539
|
+
tabs: z.ZodArray<z.ZodObject<{
|
|
10540
|
+
id: z.ZodString;
|
|
10541
|
+
title: z.ZodString;
|
|
10542
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
10543
|
+
state: z.ZodEnum<{
|
|
10544
|
+
failed: "failed";
|
|
10545
|
+
running: "running";
|
|
10546
|
+
ended: "ended";
|
|
10547
|
+
}>;
|
|
10548
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
10549
|
+
from: z.ZodNumber;
|
|
10550
|
+
lines: z.ZodArray<z.ZodString>;
|
|
10551
|
+
}, z.core.$strip>>;
|
|
10552
|
+
}, z.core.$strip>;
|
|
10553
|
+
export declare const CopilotRunCurrent: z.ZodObject<{
|
|
10554
|
+
run: z.ZodNullable<z.ZodObject<{
|
|
10555
|
+
runId: z.ZodString;
|
|
10556
|
+
jobId: z.ZodString;
|
|
10557
|
+
kind: z.ZodEnum<{
|
|
10558
|
+
repos: "repos";
|
|
10559
|
+
stale: "stale";
|
|
10560
|
+
gaps: "gaps";
|
|
10561
|
+
all: "all";
|
|
10562
|
+
}>;
|
|
10563
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10564
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
10565
|
+
state: z.ZodEnum<{
|
|
10566
|
+
done: "done";
|
|
10567
|
+
failed: "failed";
|
|
10568
|
+
running: "running";
|
|
10569
|
+
stopped: "stopped";
|
|
10570
|
+
}>;
|
|
10571
|
+
by: z.ZodOptional<z.ZodString>;
|
|
10572
|
+
startedAt: z.ZodString;
|
|
10573
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
10574
|
+
model: z.ZodOptional<z.ZodString>;
|
|
10575
|
+
progress: z.ZodObject<{
|
|
10576
|
+
repos: z.ZodNumber;
|
|
10577
|
+
repoIndex: z.ZodNumber;
|
|
10578
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
10579
|
+
session: z.ZodOptional<z.ZodString>;
|
|
10580
|
+
sessions: z.ZodNumber;
|
|
10581
|
+
}, z.core.$strip>;
|
|
10582
|
+
totals: z.ZodObject<{
|
|
10583
|
+
kept: z.ZodNumber;
|
|
10584
|
+
rejected: z.ZodNumber;
|
|
10585
|
+
tokens: z.ZodNumber;
|
|
10586
|
+
}, z.core.$strip>;
|
|
10587
|
+
message: z.ZodOptional<z.ZodString>;
|
|
10588
|
+
tabs: z.ZodArray<z.ZodObject<{
|
|
10589
|
+
id: z.ZodString;
|
|
10590
|
+
title: z.ZodString;
|
|
10591
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
10592
|
+
state: z.ZodEnum<{
|
|
10593
|
+
failed: "failed";
|
|
10594
|
+
running: "running";
|
|
10595
|
+
ended: "ended";
|
|
10596
|
+
}>;
|
|
10597
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
10598
|
+
from: z.ZodNumber;
|
|
10599
|
+
lines: z.ZodArray<z.ZodString>;
|
|
10600
|
+
}, z.core.$strip>>;
|
|
10601
|
+
}, z.core.$strip>>;
|
|
10602
|
+
allowed: z.ZodBoolean;
|
|
10603
|
+
why: z.ZodOptional<z.ZodString>;
|
|
10604
|
+
model: z.ZodOptional<z.ZodString>;
|
|
10605
|
+
}, z.core.$strip>;
|
|
10606
|
+
export type CopilotRunKindT = z.infer<typeof CopilotRunKind>;
|
|
10607
|
+
export type StartCopilotRunRequestT = z.infer<typeof StartCopilotRunRequest>;
|
|
10608
|
+
export type CopilotRunStateT = z.infer<typeof CopilotRunState>;
|
|
10609
|
+
export type CopilotRunTabT = z.infer<typeof CopilotRunTab>;
|
|
10610
|
+
export type CopilotRunViewT = z.infer<typeof CopilotRunView>;
|
|
10611
|
+
export type CopilotRunCurrentT = z.infer<typeof CopilotRunCurrent>;
|
|
10612
|
+
/** Messages on the WebSocket at /api/events. */
|
|
10613
|
+
export declare const LiveEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
10614
|
+
type: z.ZodLiteral<"file.changed">;
|
|
10615
|
+
path: z.ZodString;
|
|
10616
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10617
|
+
type: z.ZodLiteral<"job.progress">;
|
|
10618
|
+
jobId: z.ZodString;
|
|
10619
|
+
done: z.ZodNumber;
|
|
10620
|
+
total: z.ZodNumber;
|
|
10621
|
+
message: z.ZodString;
|
|
10622
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10623
|
+
type: z.ZodLiteral<"job.done">;
|
|
10624
|
+
jobId: z.ZodString;
|
|
10625
|
+
state: z.ZodEnum<{
|
|
10626
|
+
done: "done";
|
|
10627
|
+
failed: "failed";
|
|
10628
|
+
running: "running";
|
|
10629
|
+
cancelled: "cancelled";
|
|
10630
|
+
queued: "queued";
|
|
10631
|
+
}>;
|
|
10632
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10633
|
+
type: z.ZodLiteral<"index.rebuilt">;
|
|
10634
|
+
records: z.ZodNumber;
|
|
10635
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10636
|
+
type: z.ZodLiteral<"run.changed">;
|
|
10637
|
+
runId: z.ZodString;
|
|
10638
|
+
state: z.ZodEnum<{
|
|
10639
|
+
failed: "failed";
|
|
10640
|
+
prepared: "prepared";
|
|
10641
|
+
waiting: "waiting";
|
|
10642
|
+
produced: "produced";
|
|
10643
|
+
validated: "validated";
|
|
10644
|
+
cancelled: "cancelled";
|
|
10645
|
+
}>;
|
|
10646
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10647
|
+
type: z.ZodLiteral<"copilot-run.state">;
|
|
10648
|
+
run: z.ZodObject<{
|
|
10649
|
+
message: z.ZodOptional<z.ZodString>;
|
|
10650
|
+
by: z.ZodOptional<z.ZodString>;
|
|
10651
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10652
|
+
kind: z.ZodEnum<{
|
|
10653
|
+
repos: "repos";
|
|
10654
|
+
stale: "stale";
|
|
10655
|
+
gaps: "gaps";
|
|
10656
|
+
all: "all";
|
|
10657
|
+
}>;
|
|
10658
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
10659
|
+
startedAt: z.ZodString;
|
|
10660
|
+
state: z.ZodEnum<{
|
|
10661
|
+
done: "done";
|
|
10662
|
+
failed: "failed";
|
|
10663
|
+
running: "running";
|
|
10664
|
+
stopped: "stopped";
|
|
10665
|
+
}>;
|
|
10666
|
+
runId: z.ZodString;
|
|
10667
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
10668
|
+
progress: z.ZodObject<{
|
|
10669
|
+
repos: z.ZodNumber;
|
|
10670
|
+
repoIndex: z.ZodNumber;
|
|
10671
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
10672
|
+
session: z.ZodOptional<z.ZodString>;
|
|
10673
|
+
sessions: z.ZodNumber;
|
|
10674
|
+
}, z.core.$strip>;
|
|
10675
|
+
model: z.ZodOptional<z.ZodString>;
|
|
10676
|
+
jobId: z.ZodString;
|
|
10677
|
+
totals: z.ZodObject<{
|
|
10678
|
+
kept: z.ZodNumber;
|
|
10679
|
+
rejected: z.ZodNumber;
|
|
10680
|
+
tokens: z.ZodNumber;
|
|
10681
|
+
}, z.core.$strip>;
|
|
10682
|
+
}, z.core.$strip>;
|
|
10683
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
10684
|
+
type: z.ZodLiteral<"copilot-run.lines">;
|
|
10685
|
+
runId: z.ZodString;
|
|
10686
|
+
tab: z.ZodString;
|
|
10687
|
+
title: z.ZodString;
|
|
10688
|
+
at: z.ZodNumber;
|
|
10689
|
+
lines: z.ZodArray<z.ZodString>;
|
|
8001
10690
|
}, z.core.$strip>], "type">;
|
|
8002
10691
|
/** Build the OpenAPI 3.1 document from the zod schemas. */
|
|
8003
10692
|
export declare function openApiDocument(): Record<string, unknown>;
|