@maycombhq/sdk 2.0.0-beta.22 → 2.0.0-beta.24
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/api.d.ts +3075 -317
- package/npm/core/cite.d.ts +9 -2
- package/npm/core/facts-deps.d.ts +55 -0
- package/npm/core/facts-join.d.ts +94 -8
- package/npm/core/fs.d.ts +8 -0
- package/npm/core/host-questions.d.ts +105 -0
- package/npm/core/index.d.ts +5 -0
- package/npm/core/kept-files.d.ts +17 -0
- package/npm/core/light.d.ts +2 -0
- package/npm/core/log.d.ts +2 -0
- package/npm/core/manifest-edit.d.ts +21 -3
- package/npm/core/metarepo.d.ts +8 -0
- package/npm/core/orgpack-defaults.d.ts +3 -1
- package/npm/core/printer.d.ts +4 -0
- package/npm/core/question-owners.d.ts +4 -0
- package/npm/core/question-roles.d.ts +64 -4
- package/npm/core/questions.d.ts +28 -3
- package/npm/core/roles-migrate.d.ts +4 -3
- package/npm/core/run-log.d.ts +165 -0
- package/npm/core/schema/ai.d.ts +2 -2
- package/npm/core/schema/dialect.d.ts +12 -12
- package/npm/core/schema/fact-corrections.d.ts +7 -0
- package/npm/core/schema/facts.d.ts +268 -4
- package/npm/core/schema/frameworks.d.ts +10 -10
- package/npm/core/schema/orgpack.d.ts +22 -6
- package/npm/core/schema/question.d.ts +55 -2
- package/npm/core/schema/review.d.ts +2 -2
- package/npm/core/schema/scan-verify.d.ts +80 -45
- package/npm/core/setup-edit.d.ts +107 -0
- package/npm/index.js +6428 -4882
- package/package.json +1 -1
package/npm/core/api.d.ts
CHANGED
|
@@ -313,10 +313,160 @@ import { z } from "zod";
|
|
|
313
313
|
* the credential store (422). POST /api/workspace/sync and /api/reconcile answer 409 while one of
|
|
314
314
|
* their kind runs; GET /api/past-changes?change= and /api/changes/{changeId}/cockpit answer 400
|
|
315
315
|
* for a change id that isn't one, and /api/view/{name} 404 for a name that isn't a view.
|
|
316
|
+
* 3.1.0 (review round 50, ADR 0186 addendum: nothing the assistant writes stands for the person).
|
|
317
|
+
* POST /api/runs, and in model mode POST /api/changes/{changeId}/runs and .../tasks/run-ready,
|
|
318
|
+
* answer 403 unless runtime.yaml sends the model's key where the person last confirmed it (a
|
|
319
|
+
* confirmed save or Test in the AI settings, or a step they ran in their own terminal; kept
|
|
320
|
+
* outside the metarepo), or, with none confirmed yet, to a built-in provider's own address.
|
|
321
|
+
* POST /api/settings/ai/test needs `ai-test` whenever the address isn't the confirmed one, even
|
|
322
|
+
* when committed. POST /api/me/digest's `digest-send` target is the channel it posts to, read
|
|
323
|
+
* at the send (GET /api/me gives it as notify.to); `me` is refused. POST /api/runs/{runId}/done
|
|
324
|
+
* runs only the resume Atticus kept for a step the app prepared (never a file in .runs/), and
|
|
325
|
+
* only that step's own. POST /api/changes/{changeId}/workspace and .../runs answer 409 while a
|
|
326
|
+
* sync of a repo's base clone runs elsewhere. Not additive for the digest's target only: the
|
|
327
|
+
* app's page is updated with it.
|
|
328
|
+
* 3.2.0 (ADR 0187, the Console): everything Atticus is doing or did lately on this metarepo, live,
|
|
329
|
+
* wherever it was started. GET /api/activity lists the app's jobs, a Copilot run, the commands run
|
|
330
|
+
* in a terminal, an editor or a Copilot session (from .atticus/logs/running/), and the hand-off
|
|
331
|
+
* runs that wait for an assistant, newest first; GET /api/activity/{id}/lines?from=n gives one's
|
|
332
|
+
* printed lines from a line on. The live events `activity.changed` and `activity.lines` carry the
|
|
333
|
+
* same. Stop goes through the existing routes (POST /api/jobs/{jobId}/cancel, POST
|
|
334
|
+
* /api/copilot-runs/{runId}/stop); a terminal's run stops in its terminal. A Job gains `title`
|
|
335
|
+
* and the kind `work` (a request the page waits on, run as a job so the Console shows it: the
|
|
336
|
+
* critic, a wiki's sync, a step run, a run's Done; their answers are unchanged). Additive only.
|
|
337
|
+
* 3.3.0 (beta.23, Home loads fast): GET /api/setup no longer waits for the machine's checks:
|
|
338
|
+
* until they finish, its `machine` step has `checking: true` (and `done: false`), and GET
|
|
339
|
+
* /api/doctor answers when they do; `?machine=wait` waits for them as before. Additive only.
|
|
340
|
+
* 3.4.0 (app-only audit: tasks, release, archive). A Task gains `unmerged` (its branch's commits
|
|
341
|
+
* the change branch here hasn't), `decision` (a person let its work go, with why) and
|
|
342
|
+
* `repoBuilds`; POST .../tasks/{taskId}/done answers 409 for a task whose branch has commits the
|
|
343
|
+
* change branch hasn't, here or on the Git host, unless the body gives a `reason`; POST
|
|
344
|
+
* .../tasks/{taskId}/build is Build and raise PR (`raise` needs `task-pr`). Build ready, go/no-go
|
|
345
|
+
* and POST .../release-prs hold while a task branch's work isn't in the change branch.
|
|
346
|
+
* ChangeDetail's handoff gains `unpushed` and `branch` (its push failed; the branch is kept
|
|
347
|
+
* here), and POST /api/changes/{changeId}/handoff/push is Push again (`handoff`).
|
|
348
|
+
* POST /api/propose/upstream sets the upstream Bring in what merged offers, as a local job.
|
|
349
|
+
* POST /api/scan asks host questions only for repos with facts on file unless `askAll`, and
|
|
350
|
+
* its job's result says what the readers added, changed and removed (`added`, `changed`,
|
|
351
|
+
* `removed`) and how many questions it asked (`questions`).
|
|
352
|
+
* 3.5.0 (ADR 0188, a button for every step in the daily path): the local steps the app's pages
|
|
353
|
+
* named as commands, as the person's click. POST /api/facts/apply-all (`atticus verify --all
|
|
354
|
+
* --write`), POST /api/estate/join, POST /api/knowledge/sources/sync (every wiki) and POST
|
|
355
|
+
* /api/workspace/prune (`{ change? }`; uncommitted worktrees kept) run as local jobs (409 while
|
|
356
|
+
* another local step runs); GET /api/changes/{changeId}/tasks/{taskId}/context gives the task's
|
|
357
|
+
* context as markdown; PUT /api/history/recording (`{ on }`) is `atticus history on|off`. POST
|
|
358
|
+
* /api/runs and /api/runs/handoff take `map <repo>` and `change small <change>`, and `--force`
|
|
359
|
+
* on `plan stories` only (Draft the stories again); a read's Done (POST /api/runs/{runId}/done)
|
|
360
|
+
* runs `verify <repo> --write` after its last batch and says so in `applied`. Propose's `work`
|
|
361
|
+
* scope also takes a change's target-flows/ and knowledge.yaml; an answered question a read
|
|
362
|
+
* raised (rerun `atticus map <repo>`) counts in `applyFirst`. Additive only.
|
|
363
|
+
* 3.6.0 (ADR 0189, a stage is one conversation). GET /api/changes/{changeId}/stages/{stage}/thread
|
|
364
|
+
* is a stage's thread (proposal, feature, architecture, stories or small): the prompts handed to
|
|
365
|
+
* the person's assistant, its answers and what their checks said, the critic's findings, the
|
|
366
|
+
* stage's questions, the person's replies and corrections, and the questions that couldn't be
|
|
367
|
+
* kept, in order (StageThreadView). POST .../thread is a person's reply (`reply`, which the
|
|
368
|
+
* stage's next round reads as their answer), a comment on a finding (`finding`), or keeping a
|
|
369
|
+
* dropped question anyway (`keep`). The server checks a waiting hand-off's answer once its file
|
|
370
|
+
* is complete, as Done does (Done stays), and says so in the thread. A sketch stroke may be
|
|
371
|
+
* `retire` (a component taken away). Additive only.
|
|
372
|
+
* 3.7.0 (ADR 0190, set up from the app: "Edit, then Propose"). GET /api/health gains `metarepo`.
|
|
373
|
+
* GET/POST /api/setup/metarepo create the metarepo in the app's folder with init's code (the
|
|
374
|
+
* Git host manual, with the metarepo's id when known), POST /api/setup/open starts the app for
|
|
375
|
+
* another folder. POST /api/setup/repos/plan reads pasted clone URLs or a folder of clones
|
|
376
|
+
* (repos discover's code) into the repos to add, and POST /api/setup/repos writes them to the
|
|
377
|
+
* manifest. POST /api/repos/{repoId}/type/detect and PUT /api/repos/{repoId}/type detect and set
|
|
378
|
+
* a repo's type. GET /api/setup/adapters and PUT /api/setup/adapters/{kind} set runtime.yaml's
|
|
379
|
+
* outside systems; GET/PUT /api/setup/file is the raw editor of an org-pack file; POST
|
|
380
|
+
* /api/setup/patterns and /api/setup/sources add an integration pattern and a wiki. Every write
|
|
381
|
+
* takes `preview` (the lines it would change, nothing written) and answers a FileEditView; the
|
|
382
|
+
* files are then proposed for review as before. PUT /api/settings/ai's `decide` lifts a
|
|
383
|
+
* runtime.yaml of any older version to 4 (upgrade's runtime-v4 step), not only a version 3
|
|
384
|
+
* one. Additive only.
|
|
385
|
+
* 3.8.0 (ADR 0191, roles and the BA): a change goes product owner → architect → business analyst →
|
|
386
|
+
* tech lead. A question carries what it asks (`asks`, question version 6) and POST
|
|
387
|
+
* /api/questions/{id}/route moves it to another role (`routed`); GET /api/questions' `about`
|
|
388
|
+
* gains `asks`. GET /api/findings gives each finding's `asks` and takes `asks=` to filter. GET
|
|
389
|
+
* /api/changes/{changeId}/owners/suggested suggests owners from roles.yaml (version 3: a team's
|
|
390
|
+
* `roles`, the file's `defaults`). The cockpit's `waitsOn` names who the change waits on; a
|
|
391
|
+
* hand-off names the next role's owners as reviewers and tells them through the notify adapter.
|
|
392
|
+
* GET and POST /api/changes/{changeId}/work-items put the plan's feature, stories and tasks in
|
|
393
|
+
* the work tracker (manual: a step each; live: `work-items`). POST
|
|
394
|
+
* /api/owner-questions/{id}/send sends an owner question (`owner-ask`; a critic gap asked with
|
|
395
|
+
* Ask is one of them). GET /api/ask answers from the organisation's knowledge too
|
|
396
|
+
* (`knowledge`); GET /api/knowledge/search reads inputs/ when its source has no snapshot; GET
|
|
397
|
+
* /api/knowledge/passage opens a suggested section inline; a change's knowledge item carries
|
|
398
|
+
* `passage`. GET, POST /api/changes/{changeId}/stories/shape and POST
|
|
399
|
+
* .../stories/shape/{entryId}/remove are the business analyst's shaping of the stories.
|
|
400
|
+
* Additive only.
|
|
401
|
+
* 3.9.0 (ADR 0190, set up from the app, a review's fixes): GET /api/setup/adapters gains
|
|
402
|
+
* `sha256` (runtime.yaml's, as read) and PUT /api/setup/adapters/{kind} takes it back as
|
|
403
|
+
* `baseSha256`, so a form read before another edit is refused (409) rather than overwriting it.
|
|
404
|
+
* The raw editor (GET/PUT /api/setup/file) refuses a name Atticus reads written in another case
|
|
405
|
+
* (`Runtime.yaml`, 422) and a manifest listing a repo id another profile lists (422); a
|
|
406
|
+
* runtime.yaml that doesn't parse can be saved over, and new content that doesn't read is 422,
|
|
407
|
+
* never 500. POST /api/setup/sources refuses a location with a user name or password in it
|
|
408
|
+
* (422) and a sources.yaml changed meanwhile (409). POST /api/setup/repos/plan for a folder,
|
|
409
|
+
* with several platforms and none given, answers the platforms to choose from and reads
|
|
410
|
+
* nothing. Additive only.
|
|
411
|
+
* Home (beta.23 review): GET /api/changes gives each change the viewer's `yourRoles`
|
|
412
|
+
* (read from its owners as the questions' `yourRoles` are), so Home knows them for every change
|
|
413
|
+
* in flight. A `file.changed` live event says whether it can change the catalog (`catalog`),
|
|
414
|
+
* by the folders the org pack's layout names. Additive only.
|
|
415
|
+
* An editor panel (beta.23 review): POST /api/runs/{runId}/done takes
|
|
416
|
+
* `{ job: true }` and POST /api/changes/{changeId}/work-items takes `job: true`: the work runs
|
|
417
|
+
* as a job (ADR 0187, so the Console shows it), the answer is 202 JobAccepted at once, and the
|
|
418
|
+
* job's result carries the answer the call gives without it (`answer`) or its problem
|
|
419
|
+
* (`problem`). The refusals a request can know at once (409, 400, a missing confirmation) still
|
|
420
|
+
* come as the answer. Without `job` nothing changes. GET /api/activity's entries gain `rev`,
|
|
421
|
+
* the version of an entry's lines when they are rewritten rather than added to (a hand-off
|
|
422
|
+
* run's, once Done ran): the page reads them again when it changes. Additive only.
|
|
423
|
+
* Every daily step (ADR 0188, beta.23 review): nobody is left at a command to type. A step that needs a
|
|
424
|
+
* repo's base clone this machine doesn't have (Apply, Apply to every repo, the read of a repo)
|
|
425
|
+
* says what the app offers next: its job's result, or its 422 problem, carries `next: { step:
|
|
426
|
+
* "sync", repos }`, which the app shows as Sync the repos. POST /api/workspace/sync's result
|
|
427
|
+
* gives `code` and every line, its errors too. A local job's lines are in the app's words. POST
|
|
428
|
+
* /api/runs for `map <repo>` runs `verify <repo> --write` after a read that kept every fact
|
|
429
|
+
* (`applied`), as a read's Done does. A Done's resume runs as a local job (one local step at a
|
|
430
|
+
* time). Propose for review fails when its branch wasn't pushed. Additive only.
|
|
431
|
+
* 3.10.0 (beta.24, a proxy to a system outside the estate): POST /api/links/corrections, This
|
|
432
|
+
* whole arrow is wrong: one correction of every call on a link, each in its caller repo's
|
|
433
|
+
* corrections file (several lines in one write per repo, every item checked before any is
|
|
434
|
+
* written), with every file, one git command and a verify command per repo. A graph join's
|
|
435
|
+
* `how` may be `base-path` (a call whose host nothing resolves, joined by the one proxy
|
|
436
|
+
* BasePath its whole path starts with, `joined-by-base-path`). A link whose first flag is a
|
|
437
|
+
* guess is never `verified` in its join; a verified link's `how` is its verified call's, and
|
|
438
|
+
* the guesses other calls it merged rest on are its join's `also`. Repo trust (GET /api/trust) gains `secrets`: a config
|
|
439
|
+
* file's line that holds what looks like a live secret, its file and line, never its value.
|
|
440
|
+
* Review of beta.24: POST /api/links/corrections writes all or none (every file held for the
|
|
441
|
+
* batch, each written whole and renamed; a failure puts back what was written, or answers 500
|
|
442
|
+
* naming the repos written, `written`), and skips an item whose newest correction on file says
|
|
443
|
+
* the same (`skipped`), so asked again it writes nothing twice. GET /api/graph/edge-calls gives
|
|
444
|
+
* every call merged into one edge of a view, not only the 20 the view lists. Additive only.
|
|
445
|
+
* Review of beta.24 (an answer's words made into boxes): POST /api/questions/{id}/answer takes
|
|
446
|
+
* `ignore: true` (with an optional `reason`) for a question about where calls go (hosts,
|
|
447
|
+
* targets, topics, the estate's call-outs): the calls aren't real (CI/CD, a test, a template),
|
|
448
|
+
* so the join leaves them; words that name no repo, component or system are refused (400) as
|
|
449
|
+
* such an answer, and a new outside system's name is a short name, never a sentence. GET
|
|
450
|
+
* /api/trust gains `answerBoxes`, the boxes made from an answer's words, and POST
|
|
451
|
+
* /api/trust/answer-boxes/ignore and /rename put one right (preview first). Additive only.
|
|
452
|
+
* A library of the estate's own (ADR 0192): a graph edge may be `depends-on`, a component that
|
|
453
|
+
* builds on coordinates another repo's build publishes (facts v5's `dependency` and `artifact`),
|
|
454
|
+
* drawn in the architecture and repo lenses, never merged into calls or their counts; its join's
|
|
455
|
+
* `how` is `coordinates` and it carries `dependency` (group, name, version, scope), with the
|
|
456
|
+
* dependency's lines as `caller` and the publishing lines as `callee`. Additive only.
|
|
316
457
|
*/
|
|
317
|
-
export declare const API_VERSION = "3.
|
|
458
|
+
export declare const API_VERSION = "3.10.0";
|
|
318
459
|
export declare const DEFAULT_PORT = 4321;
|
|
319
460
|
/** RFC 9457 problem details, used for every error. */
|
|
461
|
+
/**
|
|
462
|
+
* 3.9.0 (ADR 0188): the step the app offers after a refusal or a failed job: Sync the repos
|
|
463
|
+
* whose base clone this machine doesn't have.
|
|
464
|
+
*/
|
|
465
|
+
export declare const NextStep: z.ZodObject<{
|
|
466
|
+
step: z.ZodLiteral<"sync">;
|
|
467
|
+
repos: z.ZodArray<z.ZodString>;
|
|
468
|
+
}, z.core.$strip>;
|
|
469
|
+
export type NextStepT = z.infer<typeof NextStep>;
|
|
320
470
|
export declare const Problem: z.ZodObject<{
|
|
321
471
|
type: z.ZodString;
|
|
322
472
|
title: z.ZodString;
|
|
@@ -330,6 +480,10 @@ export declare const Problem: z.ZodObject<{
|
|
|
330
480
|
role: z.ZodString;
|
|
331
481
|
names: z.ZodArray<z.ZodString>;
|
|
332
482
|
}, z.core.$strip>>;
|
|
483
|
+
next: z.ZodOptional<z.ZodObject<{
|
|
484
|
+
step: z.ZodLiteral<"sync">;
|
|
485
|
+
repos: z.ZodArray<z.ZodString>;
|
|
486
|
+
}, z.core.$strip>>;
|
|
333
487
|
}, z.core.$strip>;
|
|
334
488
|
export declare const CatalogRecord: z.ZodUnion<[z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, ...z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[]]>;
|
|
335
489
|
export declare const RecordPage: z.ZodObject<{
|
|
@@ -567,7 +721,7 @@ export declare const HierNode: z.ZodObject<{
|
|
|
567
721
|
why: z.ZodString;
|
|
568
722
|
}, z.core.$strip>>;
|
|
569
723
|
}, z.core.$strip>;
|
|
570
|
-
export declare const HIER_EDGE_TYPES: readonly ["calls", "publishes", "subscribes", "uses", "reads", "writes", "references", "deployed-to"];
|
|
724
|
+
export declare const HIER_EDGE_TYPES: readonly ["calls", "publishes", "subscribes", "uses", "reads", "writes", "references", "deployed-to", "depends-on"];
|
|
571
725
|
/**
|
|
572
726
|
* 2.32.0 (ADR 0135, C1): how a link's call found its callee, from its Interface's flags and via:
|
|
573
727
|
* a person's `answer`, the component (`named`) or `repo` the call names, a `host` the manifest
|
|
@@ -580,7 +734,7 @@ export declare const HIER_EDGE_TYPES: readonly ["calls", "publishes", "subscribe
|
|
|
580
734
|
* 0181): or `ai`, a pairing the AI decided (never a person's word; inferred until one corrects or
|
|
581
735
|
* confirms it).
|
|
582
736
|
*/
|
|
583
|
-
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"];
|
|
737
|
+
export declare const LINK_HOWS: readonly ["person", "answer", "named", "repo", "host", "base-path", "declared", "topic", "path", "label", "platform-setting", "folder-name", "conflict", "service-name", "shared", "ai", "coordinates", "unknown"];
|
|
584
738
|
export declare const HierJoin: z.ZodObject<{
|
|
585
739
|
interface: z.ZodString;
|
|
586
740
|
from: z.ZodString;
|
|
@@ -598,13 +752,35 @@ export declare const HierJoin: z.ZodObject<{
|
|
|
598
752
|
shared: "shared";
|
|
599
753
|
topic: "topic";
|
|
600
754
|
named: "named";
|
|
755
|
+
"base-path": "base-path";
|
|
601
756
|
"platform-setting": "platform-setting";
|
|
602
757
|
"folder-name": "folder-name";
|
|
603
758
|
conflict: "conflict";
|
|
604
759
|
"service-name": "service-name";
|
|
760
|
+
coordinates: "coordinates";
|
|
605
761
|
}>;
|
|
606
762
|
gateway: z.ZodBoolean;
|
|
607
763
|
verified: z.ZodBoolean;
|
|
764
|
+
also: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
765
|
+
unknown: "unknown";
|
|
766
|
+
ai: "ai";
|
|
767
|
+
repo: "repo";
|
|
768
|
+
path: "path";
|
|
769
|
+
host: "host";
|
|
770
|
+
label: "label";
|
|
771
|
+
answer: "answer";
|
|
772
|
+
person: "person";
|
|
773
|
+
declared: "declared";
|
|
774
|
+
shared: "shared";
|
|
775
|
+
topic: "topic";
|
|
776
|
+
named: "named";
|
|
777
|
+
"base-path": "base-path";
|
|
778
|
+
"platform-setting": "platform-setting";
|
|
779
|
+
"folder-name": "folder-name";
|
|
780
|
+
conflict: "conflict";
|
|
781
|
+
"service-name": "service-name";
|
|
782
|
+
coordinates: "coordinates";
|
|
783
|
+
}>>>;
|
|
608
784
|
method: z.ZodOptional<z.ZodString>;
|
|
609
785
|
path: z.ZodOptional<z.ZodString>;
|
|
610
786
|
caller: z.ZodArray<z.ZodObject<{
|
|
@@ -634,6 +810,12 @@ export declare const HierJoin: z.ZodObject<{
|
|
|
634
810
|
commit: z.ZodOptional<z.ZodString>;
|
|
635
811
|
}, z.core.$strip>>;
|
|
636
812
|
run: z.ZodOptional<z.ZodString>;
|
|
813
|
+
dependency: z.ZodOptional<z.ZodObject<{
|
|
814
|
+
group: z.ZodString;
|
|
815
|
+
name: z.ZodString;
|
|
816
|
+
version: z.ZodOptional<z.ZodString>;
|
|
817
|
+
scope: z.ZodOptional<z.ZodString>;
|
|
818
|
+
}, z.core.$strip>>;
|
|
637
819
|
}, z.core.$strip>;
|
|
638
820
|
/** Parallel edges between the same two nodes of the same type are one edge with a count. */
|
|
639
821
|
export declare const HierEdge: z.ZodObject<{
|
|
@@ -649,6 +831,7 @@ export declare const HierEdge: z.ZodObject<{
|
|
|
649
831
|
publishes: "publishes";
|
|
650
832
|
subscribes: "subscribes";
|
|
651
833
|
"deployed-to": "deployed-to";
|
|
834
|
+
"depends-on": "depends-on";
|
|
652
835
|
}>;
|
|
653
836
|
sync: z.ZodOptional<z.ZodEnum<{
|
|
654
837
|
sync: "sync";
|
|
@@ -686,13 +869,35 @@ export declare const HierEdge: z.ZodObject<{
|
|
|
686
869
|
shared: "shared";
|
|
687
870
|
topic: "topic";
|
|
688
871
|
named: "named";
|
|
872
|
+
"base-path": "base-path";
|
|
689
873
|
"platform-setting": "platform-setting";
|
|
690
874
|
"folder-name": "folder-name";
|
|
691
875
|
conflict: "conflict";
|
|
692
876
|
"service-name": "service-name";
|
|
877
|
+
coordinates: "coordinates";
|
|
693
878
|
}>;
|
|
694
879
|
gateway: z.ZodBoolean;
|
|
695
880
|
verified: z.ZodBoolean;
|
|
881
|
+
also: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
882
|
+
unknown: "unknown";
|
|
883
|
+
ai: "ai";
|
|
884
|
+
repo: "repo";
|
|
885
|
+
path: "path";
|
|
886
|
+
host: "host";
|
|
887
|
+
label: "label";
|
|
888
|
+
answer: "answer";
|
|
889
|
+
person: "person";
|
|
890
|
+
declared: "declared";
|
|
891
|
+
shared: "shared";
|
|
892
|
+
topic: "topic";
|
|
893
|
+
named: "named";
|
|
894
|
+
"base-path": "base-path";
|
|
895
|
+
"platform-setting": "platform-setting";
|
|
896
|
+
"folder-name": "folder-name";
|
|
897
|
+
conflict: "conflict";
|
|
898
|
+
"service-name": "service-name";
|
|
899
|
+
coordinates: "coordinates";
|
|
900
|
+
}>>>;
|
|
696
901
|
method: z.ZodOptional<z.ZodString>;
|
|
697
902
|
path: z.ZodOptional<z.ZodString>;
|
|
698
903
|
caller: z.ZodArray<z.ZodObject<{
|
|
@@ -722,6 +927,12 @@ export declare const HierEdge: z.ZodObject<{
|
|
|
722
927
|
commit: z.ZodOptional<z.ZodString>;
|
|
723
928
|
}, z.core.$strip>>;
|
|
724
929
|
run: z.ZodOptional<z.ZodString>;
|
|
930
|
+
dependency: z.ZodOptional<z.ZodObject<{
|
|
931
|
+
group: z.ZodString;
|
|
932
|
+
name: z.ZodString;
|
|
933
|
+
version: z.ZodOptional<z.ZodString>;
|
|
934
|
+
scope: z.ZodOptional<z.ZodString>;
|
|
935
|
+
}, z.core.$strip>>;
|
|
725
936
|
}, z.core.$strip>>>;
|
|
726
937
|
}, z.core.$strip>;
|
|
727
938
|
/** GET /api/graph/node/{id}: a node, its children (lazy), and its edges inside and out. */
|
|
@@ -910,6 +1121,7 @@ export declare const GraphNodeView: z.ZodObject<{
|
|
|
910
1121
|
publishes: "publishes";
|
|
911
1122
|
subscribes: "subscribes";
|
|
912
1123
|
"deployed-to": "deployed-to";
|
|
1124
|
+
"depends-on": "depends-on";
|
|
913
1125
|
}>;
|
|
914
1126
|
sync: z.ZodOptional<z.ZodEnum<{
|
|
915
1127
|
sync: "sync";
|
|
@@ -947,13 +1159,35 @@ export declare const GraphNodeView: z.ZodObject<{
|
|
|
947
1159
|
shared: "shared";
|
|
948
1160
|
topic: "topic";
|
|
949
1161
|
named: "named";
|
|
1162
|
+
"base-path": "base-path";
|
|
950
1163
|
"platform-setting": "platform-setting";
|
|
951
1164
|
"folder-name": "folder-name";
|
|
952
1165
|
conflict: "conflict";
|
|
953
1166
|
"service-name": "service-name";
|
|
1167
|
+
coordinates: "coordinates";
|
|
954
1168
|
}>;
|
|
955
1169
|
gateway: z.ZodBoolean;
|
|
956
1170
|
verified: z.ZodBoolean;
|
|
1171
|
+
also: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1172
|
+
unknown: "unknown";
|
|
1173
|
+
ai: "ai";
|
|
1174
|
+
repo: "repo";
|
|
1175
|
+
path: "path";
|
|
1176
|
+
host: "host";
|
|
1177
|
+
label: "label";
|
|
1178
|
+
answer: "answer";
|
|
1179
|
+
person: "person";
|
|
1180
|
+
declared: "declared";
|
|
1181
|
+
shared: "shared";
|
|
1182
|
+
topic: "topic";
|
|
1183
|
+
named: "named";
|
|
1184
|
+
"base-path": "base-path";
|
|
1185
|
+
"platform-setting": "platform-setting";
|
|
1186
|
+
"folder-name": "folder-name";
|
|
1187
|
+
conflict: "conflict";
|
|
1188
|
+
"service-name": "service-name";
|
|
1189
|
+
coordinates: "coordinates";
|
|
1190
|
+
}>>>;
|
|
957
1191
|
method: z.ZodOptional<z.ZodString>;
|
|
958
1192
|
path: z.ZodOptional<z.ZodString>;
|
|
959
1193
|
caller: z.ZodArray<z.ZodObject<{
|
|
@@ -983,6 +1217,12 @@ export declare const GraphNodeView: z.ZodObject<{
|
|
|
983
1217
|
commit: z.ZodOptional<z.ZodString>;
|
|
984
1218
|
}, z.core.$strip>>;
|
|
985
1219
|
run: z.ZodOptional<z.ZodString>;
|
|
1220
|
+
dependency: z.ZodOptional<z.ZodObject<{
|
|
1221
|
+
group: z.ZodString;
|
|
1222
|
+
name: z.ZodString;
|
|
1223
|
+
version: z.ZodOptional<z.ZodString>;
|
|
1224
|
+
scope: z.ZodOptional<z.ZodString>;
|
|
1225
|
+
}, z.core.$strip>>;
|
|
986
1226
|
}, z.core.$strip>>>;
|
|
987
1227
|
}, z.core.$strip>>;
|
|
988
1228
|
reduced: z.ZodBoolean;
|
|
@@ -1140,6 +1380,7 @@ export declare const GraphFocusView: z.ZodObject<{
|
|
|
1140
1380
|
publishes: "publishes";
|
|
1141
1381
|
subscribes: "subscribes";
|
|
1142
1382
|
"deployed-to": "deployed-to";
|
|
1383
|
+
"depends-on": "depends-on";
|
|
1143
1384
|
}>;
|
|
1144
1385
|
sync: z.ZodOptional<z.ZodEnum<{
|
|
1145
1386
|
sync: "sync";
|
|
@@ -1177,13 +1418,35 @@ export declare const GraphFocusView: z.ZodObject<{
|
|
|
1177
1418
|
shared: "shared";
|
|
1178
1419
|
topic: "topic";
|
|
1179
1420
|
named: "named";
|
|
1421
|
+
"base-path": "base-path";
|
|
1180
1422
|
"platform-setting": "platform-setting";
|
|
1181
1423
|
"folder-name": "folder-name";
|
|
1182
1424
|
conflict: "conflict";
|
|
1183
1425
|
"service-name": "service-name";
|
|
1426
|
+
coordinates: "coordinates";
|
|
1184
1427
|
}>;
|
|
1185
1428
|
gateway: z.ZodBoolean;
|
|
1186
1429
|
verified: z.ZodBoolean;
|
|
1430
|
+
also: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1431
|
+
unknown: "unknown";
|
|
1432
|
+
ai: "ai";
|
|
1433
|
+
repo: "repo";
|
|
1434
|
+
path: "path";
|
|
1435
|
+
host: "host";
|
|
1436
|
+
label: "label";
|
|
1437
|
+
answer: "answer";
|
|
1438
|
+
person: "person";
|
|
1439
|
+
declared: "declared";
|
|
1440
|
+
shared: "shared";
|
|
1441
|
+
topic: "topic";
|
|
1442
|
+
named: "named";
|
|
1443
|
+
"base-path": "base-path";
|
|
1444
|
+
"platform-setting": "platform-setting";
|
|
1445
|
+
"folder-name": "folder-name";
|
|
1446
|
+
conflict: "conflict";
|
|
1447
|
+
"service-name": "service-name";
|
|
1448
|
+
coordinates: "coordinates";
|
|
1449
|
+
}>>>;
|
|
1187
1450
|
method: z.ZodOptional<z.ZodString>;
|
|
1188
1451
|
path: z.ZodOptional<z.ZodString>;
|
|
1189
1452
|
caller: z.ZodArray<z.ZodObject<{
|
|
@@ -1213,9 +1476,105 @@ export declare const GraphFocusView: z.ZodObject<{
|
|
|
1213
1476
|
commit: z.ZodOptional<z.ZodString>;
|
|
1214
1477
|
}, z.core.$strip>>;
|
|
1215
1478
|
run: z.ZodOptional<z.ZodString>;
|
|
1479
|
+
dependency: z.ZodOptional<z.ZodObject<{
|
|
1480
|
+
group: z.ZodString;
|
|
1481
|
+
name: z.ZodString;
|
|
1482
|
+
version: z.ZodOptional<z.ZodString>;
|
|
1483
|
+
scope: z.ZodOptional<z.ZodString>;
|
|
1484
|
+
}, z.core.$strip>>;
|
|
1216
1485
|
}, z.core.$strip>>>;
|
|
1217
1486
|
}, z.core.$strip>>;
|
|
1218
1487
|
}, z.core.$strip>;
|
|
1488
|
+
/**
|
|
1489
|
+
* 3.10.0 (review of beta.24): GET /api/graph/edge-calls: every call merged into one edge of a
|
|
1490
|
+
* view, not only the first 20 the view lists, so "All calls on this arrow are wrong" means all.
|
|
1491
|
+
*/
|
|
1492
|
+
export declare const GraphEdgeCallsView: z.ZodObject<{
|
|
1493
|
+
edge: z.ZodString;
|
|
1494
|
+
count: z.ZodNumber;
|
|
1495
|
+
joins: z.ZodArray<z.ZodObject<{
|
|
1496
|
+
interface: z.ZodString;
|
|
1497
|
+
from: z.ZodString;
|
|
1498
|
+
to: z.ZodString;
|
|
1499
|
+
how: z.ZodEnum<{
|
|
1500
|
+
unknown: "unknown";
|
|
1501
|
+
ai: "ai";
|
|
1502
|
+
repo: "repo";
|
|
1503
|
+
path: "path";
|
|
1504
|
+
host: "host";
|
|
1505
|
+
label: "label";
|
|
1506
|
+
answer: "answer";
|
|
1507
|
+
person: "person";
|
|
1508
|
+
declared: "declared";
|
|
1509
|
+
shared: "shared";
|
|
1510
|
+
topic: "topic";
|
|
1511
|
+
named: "named";
|
|
1512
|
+
"base-path": "base-path";
|
|
1513
|
+
"platform-setting": "platform-setting";
|
|
1514
|
+
"folder-name": "folder-name";
|
|
1515
|
+
conflict: "conflict";
|
|
1516
|
+
"service-name": "service-name";
|
|
1517
|
+
coordinates: "coordinates";
|
|
1518
|
+
}>;
|
|
1519
|
+
gateway: z.ZodBoolean;
|
|
1520
|
+
verified: z.ZodBoolean;
|
|
1521
|
+
also: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1522
|
+
unknown: "unknown";
|
|
1523
|
+
ai: "ai";
|
|
1524
|
+
repo: "repo";
|
|
1525
|
+
path: "path";
|
|
1526
|
+
host: "host";
|
|
1527
|
+
label: "label";
|
|
1528
|
+
answer: "answer";
|
|
1529
|
+
person: "person";
|
|
1530
|
+
declared: "declared";
|
|
1531
|
+
shared: "shared";
|
|
1532
|
+
topic: "topic";
|
|
1533
|
+
named: "named";
|
|
1534
|
+
"base-path": "base-path";
|
|
1535
|
+
"platform-setting": "platform-setting";
|
|
1536
|
+
"folder-name": "folder-name";
|
|
1537
|
+
conflict: "conflict";
|
|
1538
|
+
"service-name": "service-name";
|
|
1539
|
+
coordinates: "coordinates";
|
|
1540
|
+
}>>>;
|
|
1541
|
+
method: z.ZodOptional<z.ZodString>;
|
|
1542
|
+
path: z.ZodOptional<z.ZodString>;
|
|
1543
|
+
caller: z.ZodArray<z.ZodObject<{
|
|
1544
|
+
source: z.ZodString;
|
|
1545
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
1546
|
+
at: z.ZodString;
|
|
1547
|
+
}, z.core.$strip>>;
|
|
1548
|
+
callee: z.ZodArray<z.ZodObject<{
|
|
1549
|
+
source: z.ZodString;
|
|
1550
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
1551
|
+
at: z.ZodString;
|
|
1552
|
+
}, z.core.$strip>>;
|
|
1553
|
+
hops: z.ZodArray<z.ZodObject<{
|
|
1554
|
+
source: z.ZodString;
|
|
1555
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
1556
|
+
at: z.ZodString;
|
|
1557
|
+
}, z.core.$strip>>;
|
|
1558
|
+
other: z.ZodArray<z.ZodObject<{
|
|
1559
|
+
source: z.ZodString;
|
|
1560
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
1561
|
+
at: z.ZodString;
|
|
1562
|
+
}, z.core.$strip>>;
|
|
1563
|
+
shared: z.ZodOptional<z.ZodObject<{
|
|
1564
|
+
team: z.ZodString;
|
|
1565
|
+
repo: z.ZodString;
|
|
1566
|
+
at: z.ZodString;
|
|
1567
|
+
commit: z.ZodOptional<z.ZodString>;
|
|
1568
|
+
}, z.core.$strip>>;
|
|
1569
|
+
run: z.ZodOptional<z.ZodString>;
|
|
1570
|
+
dependency: z.ZodOptional<z.ZodObject<{
|
|
1571
|
+
group: z.ZodString;
|
|
1572
|
+
name: z.ZodString;
|
|
1573
|
+
version: z.ZodOptional<z.ZodString>;
|
|
1574
|
+
scope: z.ZodOptional<z.ZodString>;
|
|
1575
|
+
}, z.core.$strip>>;
|
|
1576
|
+
}, z.core.$strip>>;
|
|
1577
|
+
}, z.core.$strip>;
|
|
1219
1578
|
export declare const LayoutPosition: z.ZodObject<{
|
|
1220
1579
|
x: z.ZodNumber;
|
|
1221
1580
|
y: z.ZodNumber;
|
|
@@ -1252,6 +1611,7 @@ export type HierJoinT = z.infer<typeof HierJoin>;
|
|
|
1252
1611
|
export type HierEvidenceT = z.infer<typeof HierEvidence>;
|
|
1253
1612
|
export type GraphNodeViewT = z.infer<typeof GraphNodeView>;
|
|
1254
1613
|
export type GraphFocusViewT = z.infer<typeof GraphFocusView>;
|
|
1614
|
+
export type GraphEdgeCallsViewT = z.infer<typeof GraphEdgeCallsView>;
|
|
1255
1615
|
export declare const Impact: z.ZodObject<{
|
|
1256
1616
|
root: z.ZodString;
|
|
1257
1617
|
affected: z.ZodArray<z.ZodObject<{
|
|
@@ -1333,6 +1693,7 @@ export declare const Job: z.ZodObject<{
|
|
|
1333
1693
|
scan: "scan";
|
|
1334
1694
|
reconcile: "reconcile";
|
|
1335
1695
|
intake: "intake";
|
|
1696
|
+
work: "work";
|
|
1336
1697
|
}>;
|
|
1337
1698
|
state: z.ZodEnum<{
|
|
1338
1699
|
done: "done";
|
|
@@ -1346,6 +1707,7 @@ export declare const Job: z.ZodObject<{
|
|
|
1346
1707
|
total: z.ZodNumber;
|
|
1347
1708
|
message: z.ZodString;
|
|
1348
1709
|
}, z.core.$strip>;
|
|
1710
|
+
title: z.ZodOptional<z.ZodString>;
|
|
1349
1711
|
startedAt: z.ZodString;
|
|
1350
1712
|
finishedAt: z.ZodOptional<z.ZodString>;
|
|
1351
1713
|
errors: z.ZodArray<z.ZodString>;
|
|
@@ -1419,6 +1781,12 @@ export declare const ChangeSummary: z.ZodObject<{
|
|
|
1419
1781
|
}, z.core.$strip>;
|
|
1420
1782
|
updatedAt: z.ZodString;
|
|
1421
1783
|
fastPath: z.ZodOptional<z.ZodBoolean>;
|
|
1784
|
+
yourRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1785
|
+
product: "product";
|
|
1786
|
+
architecture: "architecture";
|
|
1787
|
+
delivery: "delivery";
|
|
1788
|
+
analysis: "analysis";
|
|
1789
|
+
}>>>;
|
|
1422
1790
|
}, z.core.$strip>;
|
|
1423
1791
|
export declare const ChangeDetail: z.ZodObject<{
|
|
1424
1792
|
id: z.ZodString;
|
|
@@ -1446,6 +1814,12 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1446
1814
|
}, z.core.$strip>;
|
|
1447
1815
|
updatedAt: z.ZodString;
|
|
1448
1816
|
fastPath: z.ZodOptional<z.ZodBoolean>;
|
|
1817
|
+
yourRoles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
1818
|
+
product: "product";
|
|
1819
|
+
architecture: "architecture";
|
|
1820
|
+
delivery: "delivery";
|
|
1821
|
+
analysis: "analysis";
|
|
1822
|
+
}>>>;
|
|
1449
1823
|
notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1450
1824
|
owners: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
|
|
1451
1825
|
artifacts: z.ZodArray<z.ZodObject<{
|
|
@@ -1524,6 +1898,8 @@ export declare const ChangeDetail: z.ZodObject<{
|
|
|
1524
1898
|
merged: "merged";
|
|
1525
1899
|
closed: "closed";
|
|
1526
1900
|
}>;
|
|
1901
|
+
unpushed: z.ZodOptional<z.ZodBoolean>;
|
|
1902
|
+
branch: z.ZodOptional<z.ZodString>;
|
|
1527
1903
|
}, z.core.$strip>>;
|
|
1528
1904
|
}, z.core.$strip>;
|
|
1529
1905
|
export declare const ArtifactContent: z.ZodObject<{
|
|
@@ -1578,6 +1954,16 @@ export declare const Task: z.ZodObject<{
|
|
|
1578
1954
|
tasks: z.ZodArray<z.ZodString>;
|
|
1579
1955
|
sameRepo: z.ZodArray<z.ZodString>;
|
|
1580
1956
|
}, z.core.$strip>>;
|
|
1957
|
+
unmerged: z.ZodOptional<z.ZodObject<{
|
|
1958
|
+
commits: z.ZodNumber;
|
|
1959
|
+
branch: z.ZodString;
|
|
1960
|
+
}, z.core.$strip>>;
|
|
1961
|
+
decision: z.ZodOptional<z.ZodObject<{
|
|
1962
|
+
by: z.ZodString;
|
|
1963
|
+
at: z.ZodString;
|
|
1964
|
+
reason: z.ZodString;
|
|
1965
|
+
}, z.core.$strip>>;
|
|
1966
|
+
repoBuilds: z.ZodOptional<z.ZodBoolean>;
|
|
1581
1967
|
}, z.core.$strip>;
|
|
1582
1968
|
export type TaskT = z.infer<typeof Task>;
|
|
1583
1969
|
export declare const RunView: z.ZodObject<{
|
|
@@ -1811,6 +2197,14 @@ export declare const StartStepRequest: z.ZodObject<{
|
|
|
1811
2197
|
args: z.ZodArray<z.ZodString>;
|
|
1812
2198
|
}, z.core.$strip>;
|
|
1813
2199
|
/** 2.67.0: what Done did: the run, what it printed, and the step's next run when it offers one. */
|
|
2200
|
+
/**
|
|
2201
|
+
* 3.9.0 (review of beta.23): Done's body. `job: true` runs it as a job: 202 and the job's id at
|
|
2202
|
+
* once, the job's result `answer` the RunDoneView (or `problem`, refused), so a panel's request
|
|
2203
|
+
* never outlasts the build and commit a task run's Done makes.
|
|
2204
|
+
*/
|
|
2205
|
+
export declare const RunDoneRequest: z.ZodObject<{
|
|
2206
|
+
job: z.ZodOptional<z.ZodBoolean>;
|
|
2207
|
+
}, z.core.$strict>;
|
|
1814
2208
|
export declare const RunDoneView: z.ZodObject<{
|
|
1815
2209
|
schemaVersion: z.ZodLiteral<6>;
|
|
1816
2210
|
runId: z.ZodString;
|
|
@@ -1922,7 +2316,23 @@ export declare const RunDoneView: z.ZodObject<{
|
|
|
1922
2316
|
}, z.core.$strip>>;
|
|
1923
2317
|
lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
1924
2318
|
next: z.ZodOptional<z.ZodString>;
|
|
2319
|
+
applied: z.ZodOptional<z.ZodString>;
|
|
1925
2320
|
}, z.core.$strict>;
|
|
2321
|
+
/** 3.5.0 (ADR 0188): a task's context, as `atticus task context --markdown` prints it. */
|
|
2322
|
+
export declare const TaskContextView: z.ZodObject<{
|
|
2323
|
+
markdown: z.ZodString;
|
|
2324
|
+
}, z.core.$strip>;
|
|
2325
|
+
/** 3.5.0 (ADR 0188): this machine's prompt history recording, on or off. */
|
|
2326
|
+
export declare const HistoryRecordingRequest: z.ZodObject<{
|
|
2327
|
+
on: z.ZodBoolean;
|
|
2328
|
+
}, z.core.$strip>;
|
|
2329
|
+
export declare const HistoryRecordingView: z.ZodObject<{
|
|
2330
|
+
on: z.ZodBoolean;
|
|
2331
|
+
}, z.core.$strip>;
|
|
2332
|
+
/** 3.5.0 (ADR 0188): the worktrees cleaned up: one change's, or every change's when left out. */
|
|
2333
|
+
export declare const PruneRequest: z.ZodObject<{
|
|
2334
|
+
change: z.ZodOptional<z.ZodString>;
|
|
2335
|
+
}, z.core.$strip>;
|
|
1926
2336
|
/** 2.66.0 (UX review): the step prepared for the person's own assistant, and its run. */
|
|
1927
2337
|
export declare const PreparedStepView: z.ZodObject<{
|
|
1928
2338
|
runId: z.ZodOptional<z.ZodString>;
|
|
@@ -2649,6 +3059,11 @@ export declare const TrustRepo: z.ZodObject<{
|
|
|
2649
3059
|
}, z.core.$strip>;
|
|
2650
3060
|
unknownFiles: z.ZodArray<z.ZodString>;
|
|
2651
3061
|
commit: z.ZodOptional<z.ZodString>;
|
|
3062
|
+
secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
3063
|
+
file: z.ZodString;
|
|
3064
|
+
line: z.ZodNumber;
|
|
3065
|
+
key: z.ZodString;
|
|
3066
|
+
}, z.core.$strip>>>;
|
|
2652
3067
|
}, z.core.$strip>>;
|
|
2653
3068
|
}, z.core.$strip>;
|
|
2654
3069
|
checkout: z.ZodObject<{
|
|
@@ -2778,6 +3193,22 @@ export declare const ContractCounts: z.ZodObject<{
|
|
|
2778
3193
|
unconfirmed: z.ZodNumber;
|
|
2779
3194
|
unlinked: z.ZodOptional<z.ZodNumber>;
|
|
2780
3195
|
}, z.core.$strip>;
|
|
3196
|
+
/**
|
|
3197
|
+
* 3.10.0 (beta.24 review): a box on the map made from an answer's words, not a system's name (an
|
|
3198
|
+
* id of five or more words, or with a sentence's words in it, or a long name with spaces): a
|
|
3199
|
+
* system of a profile, the answers to questions about where calls go that name it, or both.
|
|
3200
|
+
*/
|
|
3201
|
+
export declare const AnswerBox: z.ZodObject<{
|
|
3202
|
+
id: z.ZodString;
|
|
3203
|
+
name: z.ZodString;
|
|
3204
|
+
profile: z.ZodOptional<z.ZodString>;
|
|
3205
|
+
questions: z.ZodArray<z.ZodObject<{
|
|
3206
|
+
id: z.ZodString;
|
|
3207
|
+
repo: z.ZodString;
|
|
3208
|
+
question: z.ZodString;
|
|
3209
|
+
}, z.core.$strip>>;
|
|
3210
|
+
}, z.core.$strip>;
|
|
3211
|
+
export type AnswerBoxT = z.infer<typeof AnswerBox>;
|
|
2781
3212
|
export declare const TrustView: z.ZodObject<{
|
|
2782
3213
|
factsDir: z.ZodString;
|
|
2783
3214
|
repos: z.ZodArray<z.ZodObject<{
|
|
@@ -2803,6 +3234,11 @@ export declare const TrustView: z.ZodObject<{
|
|
|
2803
3234
|
}, z.core.$strip>;
|
|
2804
3235
|
unknownFiles: z.ZodArray<z.ZodString>;
|
|
2805
3236
|
commit: z.ZodOptional<z.ZodString>;
|
|
3237
|
+
secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
3238
|
+
file: z.ZodString;
|
|
3239
|
+
line: z.ZodNumber;
|
|
3240
|
+
key: z.ZodString;
|
|
3241
|
+
}, z.core.$strip>>>;
|
|
2806
3242
|
}, z.core.$strip>>;
|
|
2807
3243
|
}, z.core.$strip>;
|
|
2808
3244
|
checkout: z.ZodObject<{
|
|
@@ -2924,6 +3360,16 @@ export declare const TrustView: z.ZodObject<{
|
|
|
2924
3360
|
}, z.core.$strip>>;
|
|
2925
3361
|
}, z.core.$strip>>;
|
|
2926
3362
|
}, z.core.$strip>>;
|
|
3363
|
+
answerBoxes: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
3364
|
+
id: z.ZodString;
|
|
3365
|
+
name: z.ZodString;
|
|
3366
|
+
profile: z.ZodOptional<z.ZodString>;
|
|
3367
|
+
questions: z.ZodArray<z.ZodObject<{
|
|
3368
|
+
id: z.ZodString;
|
|
3369
|
+
repo: z.ZodString;
|
|
3370
|
+
question: z.ZodString;
|
|
3371
|
+
}, z.core.$strip>>;
|
|
3372
|
+
}, z.core.$strip>>>;
|
|
2927
3373
|
contracts: z.ZodOptional<z.ZodObject<{
|
|
2928
3374
|
links: z.ZodNumber;
|
|
2929
3375
|
compared: z.ZodNumber;
|
|
@@ -2937,6 +3383,37 @@ export declare const TrustView: z.ZodObject<{
|
|
|
2937
3383
|
}, z.core.$strip>>;
|
|
2938
3384
|
}, z.core.$strip>;
|
|
2939
3385
|
export type TrustViewT = z.infer<typeof TrustView>;
|
|
3386
|
+
/**
|
|
3387
|
+
* 3.10.0 (beta.24 review): POST /api/trust/answer-boxes/ignore and /rename: put right a box an
|
|
3388
|
+
* answer's words made. Ignore turns each answer that names it into Ignore and takes the system out
|
|
3389
|
+
* of its profile; rename names it (a repo or system Atticus knows, or a new outside system's short
|
|
3390
|
+
* name) and points the answers at it. `preview` writes nothing. Local writes in the metarepo, for
|
|
3391
|
+
* review in the pull request (Propose for review), as the setup forms' are.
|
|
3392
|
+
*/
|
|
3393
|
+
export declare const AnswerBoxRequest: z.ZodObject<{
|
|
3394
|
+
id: z.ZodString;
|
|
3395
|
+
name: z.ZodOptional<z.ZodString>;
|
|
3396
|
+
preview: z.ZodOptional<z.ZodLiteral<true>>;
|
|
3397
|
+
}, z.core.$strict>;
|
|
3398
|
+
export declare const AnswerBoxResult: z.ZodObject<{
|
|
3399
|
+
id: z.ZodString;
|
|
3400
|
+
written: z.ZodBoolean;
|
|
3401
|
+
answers: z.ZodArray<z.ZodObject<{
|
|
3402
|
+
id: z.ZodString;
|
|
3403
|
+
repo: z.ZodString;
|
|
3404
|
+
was: z.ZodString;
|
|
3405
|
+
now: z.ZodString;
|
|
3406
|
+
}, z.core.$strip>>;
|
|
3407
|
+
profile: z.ZodOptional<z.ZodObject<{
|
|
3408
|
+
path: z.ZodString;
|
|
3409
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
3410
|
+
was: z.ZodOptional<z.ZodString>;
|
|
3411
|
+
now: z.ZodOptional<z.ZodString>;
|
|
3412
|
+
}, z.core.$strip>>;
|
|
3413
|
+
}, z.core.$strip>>;
|
|
3414
|
+
repos: z.ZodArray<z.ZodString>;
|
|
3415
|
+
}, z.core.$strip>;
|
|
3416
|
+
export type AnswerBoxResultT = z.infer<typeof AnswerBoxResult>;
|
|
2940
3417
|
/**
|
|
2941
3418
|
* 2.34.0 (ADR 0141, plan item P5): which repos' clones have moved past their facts' commit, and
|
|
2942
3419
|
* what reading each again costs, for every repo at once (the per-repo re-read plan of ADR 0124
|
|
@@ -3036,6 +3513,15 @@ export declare const ChangeKnowledgeItem: z.ZodObject<{
|
|
|
3036
3513
|
team: "team";
|
|
3037
3514
|
reference: "reference";
|
|
3038
3515
|
}>>;
|
|
3516
|
+
passage: z.ZodOptional<z.ZodObject<{
|
|
3517
|
+
source: z.ZodString;
|
|
3518
|
+
page: z.ZodString;
|
|
3519
|
+
path: z.ZodString;
|
|
3520
|
+
heading: z.ZodString;
|
|
3521
|
+
line: z.ZodNumber;
|
|
3522
|
+
text: z.ZodString;
|
|
3523
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
3524
|
+
}, z.core.$strip>>;
|
|
3039
3525
|
}, z.core.$strip>;
|
|
3040
3526
|
/**
|
|
3041
3527
|
* 2.26.0 (ADR 0124 addendum B-task-knowledge): pages that disagree about a knowledge item, what
|
|
@@ -3123,6 +3609,15 @@ export declare const ChangeKnowledgeView: z.ZodObject<{
|
|
|
3123
3609
|
team: "team";
|
|
3124
3610
|
reference: "reference";
|
|
3125
3611
|
}>>;
|
|
3612
|
+
passage: z.ZodOptional<z.ZodObject<{
|
|
3613
|
+
source: z.ZodString;
|
|
3614
|
+
page: z.ZodString;
|
|
3615
|
+
path: z.ZodString;
|
|
3616
|
+
heading: z.ZodString;
|
|
3617
|
+
line: z.ZodNumber;
|
|
3618
|
+
text: z.ZodString;
|
|
3619
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
3620
|
+
}, z.core.$strip>>;
|
|
3126
3621
|
}, z.core.$strip>>;
|
|
3127
3622
|
nearMisses: z.ZodArray<z.ZodObject<{
|
|
3128
3623
|
id: z.ZodString;
|
|
@@ -3219,8 +3714,17 @@ export declare const SetChangeKnowledgeResult: z.ZodObject<{
|
|
|
3219
3714
|
team: "team";
|
|
3220
3715
|
reference: "reference";
|
|
3221
3716
|
}>>;
|
|
3222
|
-
|
|
3223
|
-
|
|
3717
|
+
passage: z.ZodOptional<z.ZodObject<{
|
|
3718
|
+
source: z.ZodString;
|
|
3719
|
+
page: z.ZodString;
|
|
3720
|
+
path: z.ZodString;
|
|
3721
|
+
heading: z.ZodString;
|
|
3722
|
+
line: z.ZodNumber;
|
|
3723
|
+
text: z.ZodString;
|
|
3724
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
3725
|
+
}, z.core.$strip>>;
|
|
3726
|
+
}, z.core.$strip>>;
|
|
3727
|
+
nearMisses: z.ZodArray<z.ZodObject<{
|
|
3224
3728
|
id: z.ZodString;
|
|
3225
3729
|
kind: z.ZodString;
|
|
3226
3730
|
score: z.ZodNumber;
|
|
@@ -3333,6 +3837,7 @@ export declare const FactCiteView: z.ZodObject<{
|
|
|
3333
3837
|
config: "config";
|
|
3334
3838
|
component: "component";
|
|
3335
3839
|
field: "field";
|
|
3840
|
+
dependency: "dependency";
|
|
3336
3841
|
term: "term";
|
|
3337
3842
|
framework: "framework";
|
|
3338
3843
|
entry: "entry";
|
|
@@ -3340,6 +3845,7 @@ export declare const FactCiteView: z.ZodObject<{
|
|
|
3340
3845
|
call: "call";
|
|
3341
3846
|
deploy: "deploy";
|
|
3342
3847
|
flow: "flow";
|
|
3848
|
+
artifact: "artifact";
|
|
3343
3849
|
}>;
|
|
3344
3850
|
file: z.ZodString;
|
|
3345
3851
|
line: z.ZodNumber;
|
|
@@ -3425,6 +3931,7 @@ export declare const RepoFactsView: z.ZodObject<{
|
|
|
3425
3931
|
config: "config";
|
|
3426
3932
|
component: "component";
|
|
3427
3933
|
field: "field";
|
|
3934
|
+
dependency: "dependency";
|
|
3428
3935
|
term: "term";
|
|
3429
3936
|
framework: "framework";
|
|
3430
3937
|
entry: "entry";
|
|
@@ -3432,6 +3939,7 @@ export declare const RepoFactsView: z.ZodObject<{
|
|
|
3432
3939
|
call: "call";
|
|
3433
3940
|
deploy: "deploy";
|
|
3434
3941
|
flow: "flow";
|
|
3942
|
+
artifact: "artifact";
|
|
3435
3943
|
}>;
|
|
3436
3944
|
file: z.ZodString;
|
|
3437
3945
|
line: z.ZodNumber;
|
|
@@ -3511,6 +4019,7 @@ export declare const FactCorrectionResult: z.ZodObject<{
|
|
|
3511
4019
|
config: "config";
|
|
3512
4020
|
component: "component";
|
|
3513
4021
|
field: "field";
|
|
4022
|
+
dependency: "dependency";
|
|
3514
4023
|
term: "term";
|
|
3515
4024
|
framework: "framework";
|
|
3516
4025
|
entry: "entry";
|
|
@@ -3518,6 +4027,7 @@ export declare const FactCorrectionResult: z.ZodObject<{
|
|
|
3518
4027
|
call: "call";
|
|
3519
4028
|
deploy: "deploy";
|
|
3520
4029
|
flow: "flow";
|
|
4030
|
+
artifact: "artifact";
|
|
3521
4031
|
}>;
|
|
3522
4032
|
file: z.ZodString;
|
|
3523
4033
|
line: z.ZodNumber;
|
|
@@ -3565,6 +4075,97 @@ export declare const FactCorrectionResult: z.ZodObject<{
|
|
|
3565
4075
|
verify: z.ZodString;
|
|
3566
4076
|
line: z.ZodOptional<z.ZodString>;
|
|
3567
4077
|
}, z.core.$strip>;
|
|
4078
|
+
/**
|
|
4079
|
+
* 3.10.0 (beta.24): one correction of every call on an arrow between two boxes ("This whole arrow
|
|
4080
|
+
* is wrong"): each call's fact in its caller's repo, the same action for all, and the person's
|
|
4081
|
+
* why for every one (an item's own `reason` first). Every item is checked before any is written;
|
|
4082
|
+
* then each repo's corrections file takes its lines in one write.
|
|
4083
|
+
*/
|
|
4084
|
+
export declare const LinkCorrectionsRequest: z.ZodObject<{
|
|
4085
|
+
items: z.ZodArray<z.ZodObject<{
|
|
4086
|
+
repo: z.ZodString;
|
|
4087
|
+
fact: z.ZodString;
|
|
4088
|
+
action: z.ZodEnum<{
|
|
4089
|
+
wrong: "wrong";
|
|
4090
|
+
edit: "edit";
|
|
4091
|
+
}>;
|
|
4092
|
+
set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
4093
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
4094
|
+
}, z.core.$strict>>;
|
|
4095
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
4096
|
+
}, z.core.$strict>;
|
|
4097
|
+
export declare const LinkCorrectionsResult: z.ZodObject<{
|
|
4098
|
+
files: z.ZodArray<z.ZodObject<{
|
|
4099
|
+
repo: z.ZodString;
|
|
4100
|
+
file: z.ZodString;
|
|
4101
|
+
lines: z.ZodArray<z.ZodString>;
|
|
4102
|
+
corrections: z.ZodArray<z.ZodObject<{
|
|
4103
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
|
|
4104
|
+
fact: z.ZodString;
|
|
4105
|
+
target: z.ZodObject<{
|
|
4106
|
+
kind: z.ZodEnum<{
|
|
4107
|
+
config: "config";
|
|
4108
|
+
component: "component";
|
|
4109
|
+
field: "field";
|
|
4110
|
+
dependency: "dependency";
|
|
4111
|
+
term: "term";
|
|
4112
|
+
framework: "framework";
|
|
4113
|
+
entry: "entry";
|
|
4114
|
+
store: "store";
|
|
4115
|
+
call: "call";
|
|
4116
|
+
deploy: "deploy";
|
|
4117
|
+
flow: "flow";
|
|
4118
|
+
artifact: "artifact";
|
|
4119
|
+
}>;
|
|
4120
|
+
file: z.ZodString;
|
|
4121
|
+
line: z.ZodNumber;
|
|
4122
|
+
value: z.ZodString;
|
|
4123
|
+
}, z.core.$strict>;
|
|
4124
|
+
action: z.ZodEnum<{
|
|
4125
|
+
link: "link";
|
|
4126
|
+
wrong: "wrong";
|
|
4127
|
+
edit: "edit";
|
|
4128
|
+
unlink: "unlink";
|
|
4129
|
+
}>;
|
|
4130
|
+
link: z.ZodOptional<z.ZodObject<{
|
|
4131
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
4132
|
+
system: z.ZodOptional<z.ZodString>;
|
|
4133
|
+
entry: z.ZodOptional<z.ZodString>;
|
|
4134
|
+
method: z.ZodOptional<z.ZodString>;
|
|
4135
|
+
path: z.ZodString;
|
|
4136
|
+
}, z.core.$strict>>;
|
|
4137
|
+
set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
4138
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
4139
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
4140
|
+
by: z.ZodString;
|
|
4141
|
+
at: z.ZodISODateTime;
|
|
4142
|
+
ai: z.ZodOptional<z.ZodObject<{
|
|
4143
|
+
runtime: z.ZodEnum<{
|
|
4144
|
+
"hand-off": "hand-off";
|
|
4145
|
+
"copilot-acp": "copilot-acp";
|
|
4146
|
+
}>;
|
|
4147
|
+
run: z.ZodString;
|
|
4148
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
4149
|
+
confident: "confident";
|
|
4150
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
4151
|
+
"person-rule": "person-rule";
|
|
4152
|
+
}>>;
|
|
4153
|
+
}, z.core.$strict>>;
|
|
4154
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
4155
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
4156
|
+
from: z.ZodString;
|
|
4157
|
+
match: z.ZodString;
|
|
4158
|
+
}, z.core.$strict>>;
|
|
4159
|
+
match: z.ZodOptional<z.ZodString>;
|
|
4160
|
+
}, z.core.$strict>>;
|
|
4161
|
+
}, z.core.$strip>>;
|
|
4162
|
+
commit: z.ZodString;
|
|
4163
|
+
verify: z.ZodArray<z.ZodString>;
|
|
4164
|
+
skipped: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
4165
|
+
repo: z.ZodString;
|
|
4166
|
+
fact: z.ZodString;
|
|
4167
|
+
}, z.core.$strip>>>;
|
|
4168
|
+
}, z.core.$strip>;
|
|
3568
4169
|
/**
|
|
3569
4170
|
* 2.42.0 (ADR 0149, C4): after a correction the app writes, the commands a person runs (the app
|
|
3570
4171
|
* runs none) and what the next `atticus verify <repo> --write` will change, computed in-process
|
|
@@ -4554,6 +5155,9 @@ export type OutsideViewT = z.infer<typeof OutsideView>;
|
|
|
4554
5155
|
export type FactCiteViewT = z.infer<typeof FactCiteView>;
|
|
4555
5156
|
export type RepoFactsViewT = z.infer<typeof RepoFactsView>;
|
|
4556
5157
|
export type FactCorrectionResultT = z.infer<typeof FactCorrectionResult>;
|
|
5158
|
+
export type FactCorrectionRequestT = z.infer<typeof FactCorrectionRequest>;
|
|
5159
|
+
export type LinkCorrectionsRequestT = z.infer<typeof LinkCorrectionsRequest>;
|
|
5160
|
+
export type LinkCorrectionsResultT = z.infer<typeof LinkCorrectionsResult>;
|
|
4557
5161
|
/**
|
|
4558
5162
|
* 2.23.0 (ADR 0124 addendum D-app, B10): a stage tab's critic findings (the latest round of the
|
|
4559
5163
|
* stage's gate, `review/<gate>/<round>/`), each with the options it allows and the comments a
|
|
@@ -4638,8 +5242,8 @@ export declare const StageFindingView: z.ZodObject<{
|
|
|
4638
5242
|
export: "export";
|
|
4639
5243
|
manual: "manual";
|
|
4640
5244
|
}>, z.ZodEnum<{
|
|
4641
|
-
catalog: "catalog";
|
|
4642
5245
|
artifact: "artifact";
|
|
5246
|
+
catalog: "catalog";
|
|
4643
5247
|
rule: "rule";
|
|
4644
5248
|
}>]>;
|
|
4645
5249
|
record: z.ZodOptional<z.ZodString>;
|
|
@@ -4786,8 +5390,8 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4786
5390
|
export: "export";
|
|
4787
5391
|
manual: "manual";
|
|
4788
5392
|
}>, z.ZodEnum<{
|
|
4789
|
-
catalog: "catalog";
|
|
4790
5393
|
artifact: "artifact";
|
|
5394
|
+
catalog: "catalog";
|
|
4791
5395
|
rule: "rule";
|
|
4792
5396
|
}>]>;
|
|
4793
5397
|
record: z.ZodOptional<z.ZodString>;
|
|
@@ -4856,7 +5460,7 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4856
5460
|
}, z.core.$strip>>;
|
|
4857
5461
|
}, z.core.$strip>>;
|
|
4858
5462
|
questions: z.ZodArray<z.ZodObject<{
|
|
4859
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
5463
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
4860
5464
|
id: z.ZodString;
|
|
4861
5465
|
askedBy: z.ZodObject<{
|
|
4862
5466
|
step: z.ZodString;
|
|
@@ -4892,6 +5496,21 @@ export declare const StageReviewView: z.ZodObject<{
|
|
|
4892
5496
|
delivery: "delivery";
|
|
4893
5497
|
analysis: "analysis";
|
|
4894
5498
|
}>>;
|
|
5499
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
5500
|
+
business: "business";
|
|
5501
|
+
delivery: "delivery";
|
|
5502
|
+
design: "design";
|
|
5503
|
+
}>>;
|
|
5504
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
5505
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
5506
|
+
product: "product";
|
|
5507
|
+
architecture: "architecture";
|
|
5508
|
+
delivery: "delivery";
|
|
5509
|
+
analysis: "analysis";
|
|
5510
|
+
}>>;
|
|
5511
|
+
by: z.ZodString;
|
|
5512
|
+
at: z.ZodISODateTime;
|
|
5513
|
+
}, z.core.$strict>>;
|
|
4895
5514
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
4896
5515
|
finding: z.ZodOptional<z.ZodObject<{
|
|
4897
5516
|
change: z.ZodString;
|
|
@@ -5065,129 +5684,1398 @@ export declare const StageCommentResult: z.ZodObject<{
|
|
|
5065
5684
|
}, z.core.$strip>;
|
|
5066
5685
|
}, z.core.$strip>;
|
|
5067
5686
|
export type StageReviewViewT = z.infer<typeof StageReviewView>;
|
|
5068
|
-
export type StageFindingViewT = z.infer<typeof StageFindingView>;
|
|
5069
|
-
export type StageCommentResultT = z.infer<typeof StageCommentResult>;
|
|
5070
5687
|
/**
|
|
5071
|
-
*
|
|
5072
|
-
*
|
|
5073
|
-
*
|
|
5074
|
-
*
|
|
5075
|
-
*
|
|
5076
|
-
* correction (`stage/corrections.yaml`) is read by the stage's next run as the person's word in
|
|
5077
|
-
* its brief; with `scope: similar` the run applies it to every item like it. After the run it is
|
|
5078
|
-
* `applied` when the draft changed its item (else `read`), and `touched` lists the other items
|
|
5079
|
-
* the draft changed for it. Kept on file either way.
|
|
5688
|
+
* 3.5.0 (ADR 0189): a stage of a change as one conversation, assembled from the files that hold
|
|
5689
|
+
* it (the runs, the stage's loop file, the critic's rounds, the questions, the corrections). The
|
|
5690
|
+
* thread is a view and the place to reply: the AI still runs in the person's editor (a hand-off),
|
|
5691
|
+
* unattended Copilot or a server model. Items are in order; a prompt's sizes, model and file
|
|
5692
|
+
* paths are its `details`, for a Details disclosure.
|
|
5080
5693
|
*/
|
|
5081
|
-
export declare const
|
|
5082
|
-
export declare const
|
|
5694
|
+
export declare const THREAD_STAGES: readonly ["proposal", "feature", "architecture", "stories", "small"];
|
|
5695
|
+
export declare const ThreadStage: z.ZodEnum<{
|
|
5696
|
+
small: "small";
|
|
5083
5697
|
architecture: "architecture";
|
|
5698
|
+
proposal: "proposal";
|
|
5084
5699
|
stories: "stories";
|
|
5085
|
-
tasks: "tasks";
|
|
5086
5700
|
feature: "feature";
|
|
5087
5701
|
}>;
|
|
5088
|
-
export declare const
|
|
5089
|
-
|
|
5090
|
-
|
|
5091
|
-
|
|
5092
|
-
|
|
5093
|
-
|
|
5094
|
-
|
|
5095
|
-
|
|
5096
|
-
at: z.ZodOptional<z.ZodString>;
|
|
5097
|
-
}, z.core.$strip>;
|
|
5098
|
-
export declare const DraftItemView: z.ZodObject<{
|
|
5099
|
-
id: z.ZodString;
|
|
5100
|
-
label: z.ZodString;
|
|
5101
|
-
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5102
|
-
}, z.core.$strip>;
|
|
5103
|
-
export declare const DraftFileView: z.ZodObject<{
|
|
5104
|
-
file: z.ZodString;
|
|
5105
|
-
path: z.ZodString;
|
|
5106
|
-
stage: z.ZodString;
|
|
5107
|
-
drafted: z.ZodOptional<z.ZodObject<{
|
|
5108
|
-
by: z.ZodEnum<{
|
|
5109
|
-
ai: "ai";
|
|
5110
|
-
person: "person";
|
|
5111
|
-
}>;
|
|
5112
|
-
stage: z.ZodOptional<z.ZodString>;
|
|
5113
|
-
run: z.ZodOptional<z.ZodString>;
|
|
5114
|
-
who: z.ZodOptional<z.ZodString>;
|
|
5115
|
-
at: z.ZodOptional<z.ZodString>;
|
|
5116
|
-
}, z.core.$strip>>;
|
|
5117
|
-
items: z.ZodArray<z.ZodObject<{
|
|
5118
|
-
id: z.ZodString;
|
|
5119
|
-
label: z.ZodString;
|
|
5120
|
-
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
5121
|
-
}, z.core.$strip>>;
|
|
5702
|
+
export declare const ThreadRunDetails: z.ZodObject<{
|
|
5703
|
+
agent: z.ZodString;
|
|
5704
|
+
runtime: z.ZodString;
|
|
5705
|
+
promptPath: z.ZodString;
|
|
5706
|
+
output: z.ZodOptional<z.ZodString>;
|
|
5707
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
5708
|
+
model: z.ZodOptional<z.ZodString>;
|
|
5709
|
+
attempt: z.ZodNumber;
|
|
5122
5710
|
}, z.core.$strip>;
|
|
5123
|
-
export declare const
|
|
5124
|
-
|
|
5125
|
-
stage: z.ZodString;
|
|
5126
|
-
file: z.ZodString;
|
|
5127
|
-
item: z.ZodOptional<z.ZodString>;
|
|
5128
|
-
label: z.ZodString;
|
|
5129
|
-
text: z.ZodString;
|
|
5130
|
-
scope: z.ZodEnum<{
|
|
5131
|
-
one: "one";
|
|
5132
|
-
similar: "similar";
|
|
5133
|
-
}>;
|
|
5134
|
-
like: z.ZodOptional<z.ZodString>;
|
|
5135
|
-
by: z.ZodString;
|
|
5711
|
+
export declare const ThreadItem: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
5712
|
+
kind: z.ZodLiteral<"prompt">;
|
|
5136
5713
|
at: z.ZodString;
|
|
5714
|
+
runId: z.ZodString;
|
|
5715
|
+
who: z.ZodEnum<{
|
|
5716
|
+
critic: "critic";
|
|
5717
|
+
drafter: "drafter";
|
|
5718
|
+
}>;
|
|
5719
|
+
prompt: z.ZodString;
|
|
5137
5720
|
state: z.ZodEnum<{
|
|
5138
|
-
|
|
5139
|
-
|
|
5721
|
+
failed: "failed";
|
|
5722
|
+
prepared: "prepared";
|
|
5140
5723
|
waiting: "waiting";
|
|
5724
|
+
produced: "produced";
|
|
5725
|
+
validated: "validated";
|
|
5726
|
+
cancelled: "cancelled";
|
|
5141
5727
|
}>;
|
|
5142
|
-
|
|
5143
|
-
|
|
5144
|
-
|
|
5145
|
-
|
|
5146
|
-
|
|
5147
|
-
|
|
5148
|
-
|
|
5149
|
-
|
|
5150
|
-
|
|
5151
|
-
|
|
5152
|
-
|
|
5153
|
-
|
|
5728
|
+
details: z.ZodObject<{
|
|
5729
|
+
agent: z.ZodString;
|
|
5730
|
+
runtime: z.ZodString;
|
|
5731
|
+
promptPath: z.ZodString;
|
|
5732
|
+
output: z.ZodOptional<z.ZodString>;
|
|
5733
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
5734
|
+
model: z.ZodOptional<z.ZodString>;
|
|
5735
|
+
attempt: z.ZodNumber;
|
|
5736
|
+
}, z.core.$strip>;
|
|
5737
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5738
|
+
kind: z.ZodLiteral<"answer">;
|
|
5739
|
+
at: z.ZodString;
|
|
5740
|
+
runId: z.ZodString;
|
|
5741
|
+
who: z.ZodEnum<{
|
|
5742
|
+
critic: "critic";
|
|
5743
|
+
drafter: "drafter";
|
|
5154
5744
|
}>;
|
|
5155
|
-
|
|
5156
|
-
|
|
5157
|
-
|
|
5158
|
-
|
|
5159
|
-
|
|
5160
|
-
|
|
5161
|
-
|
|
5162
|
-
|
|
5163
|
-
|
|
5164
|
-
|
|
5165
|
-
|
|
5166
|
-
|
|
5167
|
-
|
|
5168
|
-
|
|
5169
|
-
|
|
5745
|
+
checked: z.ZodEnum<{
|
|
5746
|
+
failed: "failed";
|
|
5747
|
+
passed: "passed";
|
|
5748
|
+
checking: "checking";
|
|
5749
|
+
}>;
|
|
5750
|
+
by: z.ZodOptional<z.ZodEnum<{
|
|
5751
|
+
person: "person";
|
|
5752
|
+
app: "app";
|
|
5753
|
+
}>>;
|
|
5754
|
+
summary: z.ZodArray<z.ZodString>;
|
|
5755
|
+
problems: z.ZodArray<z.ZodString>;
|
|
5756
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5757
|
+
kind: z.ZodLiteral<"changed">;
|
|
5758
|
+
at: z.ZodString;
|
|
5759
|
+
files: z.ZodArray<z.ZodString>;
|
|
5760
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5761
|
+
kind: z.ZodLiteral<"finding">;
|
|
5762
|
+
at: z.ZodString;
|
|
5763
|
+
view: z.ZodObject<{
|
|
5764
|
+
finding: z.ZodObject<{
|
|
5765
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
5170
5766
|
id: z.ZodString;
|
|
5171
|
-
|
|
5172
|
-
|
|
5173
|
-
|
|
5174
|
-
|
|
5175
|
-
|
|
5176
|
-
|
|
5177
|
-
|
|
5178
|
-
|
|
5179
|
-
|
|
5180
|
-
|
|
5181
|
-
|
|
5182
|
-
|
|
5183
|
-
|
|
5184
|
-
|
|
5185
|
-
|
|
5186
|
-
|
|
5187
|
-
|
|
5188
|
-
|
|
5189
|
-
|
|
5190
|
-
|
|
5767
|
+
kind: z.ZodEnum<{
|
|
5768
|
+
issue: "issue";
|
|
5769
|
+
"knowledge-gap": "knowledge-gap";
|
|
5770
|
+
}>;
|
|
5771
|
+
change: z.ZodString;
|
|
5772
|
+
gate: z.ZodString;
|
|
5773
|
+
round: z.ZodNumber;
|
|
5774
|
+
rule: z.ZodString;
|
|
5775
|
+
layer: z.ZodEnum<{
|
|
5776
|
+
team: "team";
|
|
5777
|
+
constitution: "constitution";
|
|
5778
|
+
org: "org";
|
|
5779
|
+
}>;
|
|
5780
|
+
lens: z.ZodEnum<{
|
|
5781
|
+
release: "release";
|
|
5782
|
+
true: "true";
|
|
5783
|
+
complete: "complete";
|
|
5784
|
+
safe: "safe";
|
|
5785
|
+
ship: "ship";
|
|
5786
|
+
business: "business";
|
|
5787
|
+
architecture: "architecture";
|
|
5788
|
+
story: "story";
|
|
5789
|
+
ux: "ux";
|
|
5790
|
+
delivery: "delivery";
|
|
5791
|
+
"code-and-test": "code-and-test";
|
|
5792
|
+
}>;
|
|
5793
|
+
severity: z.ZodEnum<{
|
|
5794
|
+
blocking: "blocking";
|
|
5795
|
+
gap: "gap";
|
|
5796
|
+
risk: "risk";
|
|
5797
|
+
idea: "idea";
|
|
5798
|
+
}>;
|
|
5799
|
+
artifact: z.ZodString;
|
|
5800
|
+
locator: z.ZodObject<{
|
|
5801
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5802
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
5803
|
+
record: z.ZodOptional<z.ZodString>;
|
|
5804
|
+
field: z.ZodOptional<z.ZodString>;
|
|
5805
|
+
}, z.core.$strict>;
|
|
5806
|
+
summary: z.ZodString;
|
|
5807
|
+
why: z.ZodString;
|
|
5808
|
+
fix: z.ZodObject<{
|
|
5809
|
+
text: z.ZodString;
|
|
5810
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
5811
|
+
}, z.core.$strict>;
|
|
5812
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
5813
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
5814
|
+
code: "code";
|
|
5815
|
+
config: "config";
|
|
5816
|
+
spec: "spec";
|
|
5817
|
+
gateway: "gateway";
|
|
5818
|
+
"event-config": "event-config";
|
|
5819
|
+
infrastructure: "infrastructure";
|
|
5820
|
+
pipeline: "pipeline";
|
|
5821
|
+
migration: "migration";
|
|
5822
|
+
diagram: "diagram";
|
|
5823
|
+
document: "document";
|
|
5824
|
+
export: "export";
|
|
5825
|
+
manual: "manual";
|
|
5826
|
+
}>, z.ZodEnum<{
|
|
5827
|
+
artifact: "artifact";
|
|
5828
|
+
catalog: "catalog";
|
|
5829
|
+
rule: "rule";
|
|
5830
|
+
}>]>;
|
|
5831
|
+
record: z.ZodOptional<z.ZodString>;
|
|
5832
|
+
path: z.ZodOptional<z.ZodString>;
|
|
5833
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
5834
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5835
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
5836
|
+
}, z.core.$strict>>;
|
|
5837
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
5838
|
+
text: z.ZodString;
|
|
5839
|
+
owner: z.ZodString;
|
|
5840
|
+
}, z.core.$strict>>;
|
|
5841
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
5842
|
+
question: z.ZodString;
|
|
5843
|
+
quote: z.ZodString;
|
|
5844
|
+
}, z.core.$strict>>;
|
|
5845
|
+
waivable: z.ZodBoolean;
|
|
5846
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
5847
|
+
open: "open";
|
|
5848
|
+
applied: "applied";
|
|
5849
|
+
dismissed: "dismissed";
|
|
5850
|
+
waived: "waived";
|
|
5851
|
+
asked: "asked";
|
|
5852
|
+
}>>;
|
|
5853
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
5854
|
+
action: z.ZodEnum<{
|
|
5855
|
+
apply: "apply";
|
|
5856
|
+
"edit-and-apply": "edit-and-apply";
|
|
5857
|
+
"not-relevant": "not-relevant";
|
|
5858
|
+
waive: "waive";
|
|
5859
|
+
ask: "ask";
|
|
5860
|
+
}>;
|
|
5861
|
+
by: z.ZodString;
|
|
5862
|
+
at: z.ZodISODateTime;
|
|
5863
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
5864
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
5865
|
+
}, z.core.$strict>>;
|
|
5866
|
+
createdAt: z.ZodISODateTime;
|
|
5867
|
+
}, z.core.$strict>;
|
|
5868
|
+
file: z.ZodString;
|
|
5869
|
+
options: z.ZodObject<{
|
|
5870
|
+
fix: z.ZodString;
|
|
5871
|
+
apply: z.ZodBoolean;
|
|
5872
|
+
dismiss: z.ZodBoolean;
|
|
5873
|
+
waive: z.ZodBoolean;
|
|
5874
|
+
ask: z.ZodOptional<z.ZodObject<{
|
|
5875
|
+
text: z.ZodString;
|
|
5876
|
+
owner: z.ZodString;
|
|
5877
|
+
}, z.core.$strip>>;
|
|
5878
|
+
}, z.core.$strip>;
|
|
5879
|
+
comments: z.ZodArray<z.ZodObject<{
|
|
5880
|
+
question: z.ZodString;
|
|
5881
|
+
text: z.ZodString;
|
|
5882
|
+
by: z.ZodString;
|
|
5883
|
+
at: z.ZodString;
|
|
5884
|
+
read: z.ZodBoolean;
|
|
5885
|
+
}, z.core.$strip>>;
|
|
5886
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
5887
|
+
claim: z.ZodEnum<{
|
|
5888
|
+
fixed: "fixed";
|
|
5889
|
+
"not-relevant": "not-relevant";
|
|
5890
|
+
}>;
|
|
5891
|
+
by: z.ZodString;
|
|
5892
|
+
at: z.ZodString;
|
|
5893
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
5894
|
+
}, z.core.$strip>>;
|
|
5895
|
+
}, z.core.$strip>;
|
|
5896
|
+
assistantWrites: z.ZodBoolean;
|
|
5897
|
+
edit: z.ZodOptional<z.ZodObject<{
|
|
5898
|
+
artifact: z.ZodString;
|
|
5899
|
+
file: z.ZodOptional<z.ZodString>;
|
|
5900
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
5901
|
+
}, z.core.$strip>>;
|
|
5902
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
5903
|
+
kind: z.ZodLiteral<"question">;
|
|
5904
|
+
at: z.ZodString;
|
|
5905
|
+
question: z.ZodObject<{
|
|
5906
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
5907
|
+
id: z.ZodString;
|
|
5908
|
+
askedBy: z.ZodObject<{
|
|
5909
|
+
step: z.ZodString;
|
|
5910
|
+
command: z.ZodString;
|
|
5911
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5912
|
+
at: z.ZodISODateTime;
|
|
5913
|
+
}, z.core.$strict>;
|
|
5914
|
+
alsoAskedBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
5915
|
+
step: z.ZodString;
|
|
5916
|
+
command: z.ZodString;
|
|
5917
|
+
run: z.ZodOptional<z.ZodString>;
|
|
5918
|
+
at: z.ZodISODateTime;
|
|
5919
|
+
rerun: z.ZodString;
|
|
5920
|
+
}, z.core.$strict>>>;
|
|
5921
|
+
repo: z.ZodString;
|
|
5922
|
+
question: z.ZodString;
|
|
5923
|
+
options: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
5924
|
+
label: z.ZodString;
|
|
5925
|
+
means: z.ZodString;
|
|
5926
|
+
changes: z.ZodString;
|
|
5927
|
+
}, z.core.$strict>>>;
|
|
5928
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
5929
|
+
scope: z.ZodObject<{
|
|
5930
|
+
level: z.ZodEnum<{
|
|
5931
|
+
repo: "repo";
|
|
5932
|
+
"repo-type": "repo-type";
|
|
5933
|
+
}>;
|
|
5934
|
+
id: z.ZodString;
|
|
5935
|
+
}, z.core.$strict>;
|
|
5936
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
5937
|
+
product: "product";
|
|
5938
|
+
architecture: "architecture";
|
|
5939
|
+
delivery: "delivery";
|
|
5940
|
+
analysis: "analysis";
|
|
5941
|
+
}>>;
|
|
5942
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
5943
|
+
business: "business";
|
|
5944
|
+
delivery: "delivery";
|
|
5945
|
+
design: "design";
|
|
5946
|
+
}>>;
|
|
5947
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
5948
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
5949
|
+
product: "product";
|
|
5950
|
+
architecture: "architecture";
|
|
5951
|
+
delivery: "delivery";
|
|
5952
|
+
analysis: "analysis";
|
|
5953
|
+
}>>;
|
|
5954
|
+
by: z.ZodString;
|
|
5955
|
+
at: z.ZodISODateTime;
|
|
5956
|
+
}, z.core.$strict>>;
|
|
5957
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
5958
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
5959
|
+
change: z.ZodString;
|
|
5960
|
+
gate: z.ZodString;
|
|
5961
|
+
round: z.ZodNumber;
|
|
5962
|
+
id: z.ZodString;
|
|
5963
|
+
}, z.core.$strict>>;
|
|
5964
|
+
state: z.ZodEnum<{
|
|
5965
|
+
retired: "retired";
|
|
5966
|
+
open: "open";
|
|
5967
|
+
answered: "answered";
|
|
5968
|
+
}>;
|
|
5969
|
+
rerun: z.ZodString;
|
|
5970
|
+
answer: z.ZodOptional<z.ZodObject<{
|
|
5971
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
5972
|
+
text: z.ZodOptional<z.ZodString>;
|
|
5973
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
5974
|
+
kind: z.ZodLiteral<"ai">;
|
|
5975
|
+
runtime: z.ZodEnum<{
|
|
5976
|
+
"hand-off": "hand-off";
|
|
5977
|
+
"copilot-acp": "copilot-acp";
|
|
5978
|
+
}>;
|
|
5979
|
+
run: z.ZodString;
|
|
5980
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
5981
|
+
confident: "confident";
|
|
5982
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
5983
|
+
"person-rule": "person-rule";
|
|
5984
|
+
}>>;
|
|
5985
|
+
}, z.core.$strict>]>;
|
|
5986
|
+
at: z.ZodISODateTime;
|
|
5987
|
+
scope: z.ZodObject<{
|
|
5988
|
+
level: z.ZodEnum<{
|
|
5989
|
+
repo: "repo";
|
|
5990
|
+
"repo-type": "repo-type";
|
|
5991
|
+
}>;
|
|
5992
|
+
id: z.ZodString;
|
|
5993
|
+
}, z.core.$strict>;
|
|
5994
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
5995
|
+
match: z.ZodOptional<z.ZodString>;
|
|
5996
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
5997
|
+
by: z.ZodString;
|
|
5998
|
+
at: z.ZodISODateTime;
|
|
5999
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6000
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6001
|
+
file: z.ZodString;
|
|
6002
|
+
line: z.ZodNumber;
|
|
6003
|
+
quote: z.ZodString;
|
|
6004
|
+
}, z.core.$strict>>;
|
|
6005
|
+
}, z.core.$strict>>;
|
|
6006
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6007
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6008
|
+
from: z.ZodString;
|
|
6009
|
+
match: z.ZodString;
|
|
6010
|
+
}, z.core.$strict>>;
|
|
6011
|
+
}, z.core.$strict>>;
|
|
6012
|
+
retired: z.ZodOptional<z.ZodObject<{
|
|
6013
|
+
at: z.ZodISODateTime;
|
|
6014
|
+
why: z.ZodString;
|
|
6015
|
+
replacedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6016
|
+
}, z.core.$strict>>;
|
|
6017
|
+
reopened: z.ZodOptional<z.ZodObject<{
|
|
6018
|
+
at: z.ZodISODateTime;
|
|
6019
|
+
why: z.ZodString;
|
|
6020
|
+
answer: z.ZodObject<{
|
|
6021
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6022
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6023
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6024
|
+
kind: z.ZodLiteral<"ai">;
|
|
6025
|
+
runtime: z.ZodEnum<{
|
|
6026
|
+
"hand-off": "hand-off";
|
|
6027
|
+
"copilot-acp": "copilot-acp";
|
|
6028
|
+
}>;
|
|
6029
|
+
run: z.ZodString;
|
|
6030
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6031
|
+
confident: "confident";
|
|
6032
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6033
|
+
"person-rule": "person-rule";
|
|
6034
|
+
}>>;
|
|
6035
|
+
}, z.core.$strict>]>;
|
|
6036
|
+
at: z.ZodISODateTime;
|
|
6037
|
+
scope: z.ZodObject<{
|
|
6038
|
+
level: z.ZodEnum<{
|
|
6039
|
+
repo: "repo";
|
|
6040
|
+
"repo-type": "repo-type";
|
|
6041
|
+
}>;
|
|
6042
|
+
id: z.ZodString;
|
|
6043
|
+
}, z.core.$strict>;
|
|
6044
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6045
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6046
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6047
|
+
by: z.ZodString;
|
|
6048
|
+
at: z.ZodISODateTime;
|
|
6049
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6050
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6051
|
+
file: z.ZodString;
|
|
6052
|
+
line: z.ZodNumber;
|
|
6053
|
+
quote: z.ZodString;
|
|
6054
|
+
}, z.core.$strict>>;
|
|
6055
|
+
}, z.core.$strict>>;
|
|
6056
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6057
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6058
|
+
from: z.ZodString;
|
|
6059
|
+
match: z.ZodString;
|
|
6060
|
+
}, z.core.$strict>>;
|
|
6061
|
+
}, z.core.$strict>;
|
|
6062
|
+
}, z.core.$strict>>;
|
|
6063
|
+
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6064
|
+
id: z.ZodString;
|
|
6065
|
+
verdict: z.ZodEnum<{
|
|
6066
|
+
unsure: "unsure";
|
|
6067
|
+
narrower: "narrower";
|
|
6068
|
+
}>;
|
|
6069
|
+
judgment: z.ZodOptional<z.ZodString>;
|
|
6070
|
+
}, z.core.$strict>>>;
|
|
6071
|
+
}, z.core.$strict>;
|
|
6072
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6073
|
+
kind: z.ZodLiteral<"reply">;
|
|
6074
|
+
at: z.ZodString;
|
|
6075
|
+
text: z.ZodString;
|
|
6076
|
+
by: z.ZodString;
|
|
6077
|
+
read: z.ZodBoolean;
|
|
6078
|
+
about: z.ZodOptional<z.ZodString>;
|
|
6079
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6080
|
+
kind: z.ZodLiteral<"correction">;
|
|
6081
|
+
at: z.ZodString;
|
|
6082
|
+
text: z.ZodString;
|
|
6083
|
+
label: z.ZodString;
|
|
6084
|
+
by: z.ZodString;
|
|
6085
|
+
state: z.ZodString;
|
|
6086
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6087
|
+
kind: z.ZodLiteral<"dropped">;
|
|
6088
|
+
at: z.ZodString;
|
|
6089
|
+
key: z.ZodString;
|
|
6090
|
+
question: z.ZodString;
|
|
6091
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6092
|
+
nearest: z.ZodOptional<z.ZodString>;
|
|
6093
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6094
|
+
kind: z.ZodLiteral<"note">;
|
|
6095
|
+
at: z.ZodString;
|
|
6096
|
+
text: z.ZodString;
|
|
6097
|
+
}, z.core.$strip>], "kind">;
|
|
6098
|
+
export declare const StageThreadView: z.ZodObject<{
|
|
6099
|
+
change: z.ZodString;
|
|
6100
|
+
stage: z.ZodEnum<{
|
|
6101
|
+
small: "small";
|
|
6102
|
+
architecture: "architecture";
|
|
6103
|
+
proposal: "proposal";
|
|
6104
|
+
stories: "stories";
|
|
6105
|
+
feature: "feature";
|
|
6106
|
+
}>;
|
|
6107
|
+
state: z.ZodEnum<{
|
|
6108
|
+
"not-started": "not-started";
|
|
6109
|
+
done: "done";
|
|
6110
|
+
questions: "questions";
|
|
6111
|
+
waiting: "waiting";
|
|
6112
|
+
stopped: "stopped";
|
|
6113
|
+
drafting: "drafting";
|
|
6114
|
+
}>;
|
|
6115
|
+
headline: z.ZodString;
|
|
6116
|
+
items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
6117
|
+
kind: z.ZodLiteral<"prompt">;
|
|
6118
|
+
at: z.ZodString;
|
|
6119
|
+
runId: z.ZodString;
|
|
6120
|
+
who: z.ZodEnum<{
|
|
6121
|
+
critic: "critic";
|
|
6122
|
+
drafter: "drafter";
|
|
6123
|
+
}>;
|
|
6124
|
+
prompt: z.ZodString;
|
|
6125
|
+
state: z.ZodEnum<{
|
|
6126
|
+
failed: "failed";
|
|
6127
|
+
prepared: "prepared";
|
|
6128
|
+
waiting: "waiting";
|
|
6129
|
+
produced: "produced";
|
|
6130
|
+
validated: "validated";
|
|
6131
|
+
cancelled: "cancelled";
|
|
6132
|
+
}>;
|
|
6133
|
+
details: z.ZodObject<{
|
|
6134
|
+
agent: z.ZodString;
|
|
6135
|
+
runtime: z.ZodString;
|
|
6136
|
+
promptPath: z.ZodString;
|
|
6137
|
+
output: z.ZodOptional<z.ZodString>;
|
|
6138
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
6139
|
+
model: z.ZodOptional<z.ZodString>;
|
|
6140
|
+
attempt: z.ZodNumber;
|
|
6141
|
+
}, z.core.$strip>;
|
|
6142
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6143
|
+
kind: z.ZodLiteral<"answer">;
|
|
6144
|
+
at: z.ZodString;
|
|
6145
|
+
runId: z.ZodString;
|
|
6146
|
+
who: z.ZodEnum<{
|
|
6147
|
+
critic: "critic";
|
|
6148
|
+
drafter: "drafter";
|
|
6149
|
+
}>;
|
|
6150
|
+
checked: z.ZodEnum<{
|
|
6151
|
+
failed: "failed";
|
|
6152
|
+
passed: "passed";
|
|
6153
|
+
checking: "checking";
|
|
6154
|
+
}>;
|
|
6155
|
+
by: z.ZodOptional<z.ZodEnum<{
|
|
6156
|
+
person: "person";
|
|
6157
|
+
app: "app";
|
|
6158
|
+
}>>;
|
|
6159
|
+
summary: z.ZodArray<z.ZodString>;
|
|
6160
|
+
problems: z.ZodArray<z.ZodString>;
|
|
6161
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6162
|
+
kind: z.ZodLiteral<"changed">;
|
|
6163
|
+
at: z.ZodString;
|
|
6164
|
+
files: z.ZodArray<z.ZodString>;
|
|
6165
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6166
|
+
kind: z.ZodLiteral<"finding">;
|
|
6167
|
+
at: z.ZodString;
|
|
6168
|
+
view: z.ZodObject<{
|
|
6169
|
+
finding: z.ZodObject<{
|
|
6170
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
6171
|
+
id: z.ZodString;
|
|
6172
|
+
kind: z.ZodEnum<{
|
|
6173
|
+
issue: "issue";
|
|
6174
|
+
"knowledge-gap": "knowledge-gap";
|
|
6175
|
+
}>;
|
|
6176
|
+
change: z.ZodString;
|
|
6177
|
+
gate: z.ZodString;
|
|
6178
|
+
round: z.ZodNumber;
|
|
6179
|
+
rule: z.ZodString;
|
|
6180
|
+
layer: z.ZodEnum<{
|
|
6181
|
+
team: "team";
|
|
6182
|
+
constitution: "constitution";
|
|
6183
|
+
org: "org";
|
|
6184
|
+
}>;
|
|
6185
|
+
lens: z.ZodEnum<{
|
|
6186
|
+
release: "release";
|
|
6187
|
+
true: "true";
|
|
6188
|
+
complete: "complete";
|
|
6189
|
+
safe: "safe";
|
|
6190
|
+
ship: "ship";
|
|
6191
|
+
business: "business";
|
|
6192
|
+
architecture: "architecture";
|
|
6193
|
+
story: "story";
|
|
6194
|
+
ux: "ux";
|
|
6195
|
+
delivery: "delivery";
|
|
6196
|
+
"code-and-test": "code-and-test";
|
|
6197
|
+
}>;
|
|
6198
|
+
severity: z.ZodEnum<{
|
|
6199
|
+
blocking: "blocking";
|
|
6200
|
+
gap: "gap";
|
|
6201
|
+
risk: "risk";
|
|
6202
|
+
idea: "idea";
|
|
6203
|
+
}>;
|
|
6204
|
+
artifact: z.ZodString;
|
|
6205
|
+
locator: z.ZodObject<{
|
|
6206
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6207
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
6208
|
+
record: z.ZodOptional<z.ZodString>;
|
|
6209
|
+
field: z.ZodOptional<z.ZodString>;
|
|
6210
|
+
}, z.core.$strict>;
|
|
6211
|
+
summary: z.ZodString;
|
|
6212
|
+
why: z.ZodString;
|
|
6213
|
+
fix: z.ZodObject<{
|
|
6214
|
+
text: z.ZodString;
|
|
6215
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
6216
|
+
}, z.core.$strict>;
|
|
6217
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
6218
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
6219
|
+
code: "code";
|
|
6220
|
+
config: "config";
|
|
6221
|
+
spec: "spec";
|
|
6222
|
+
gateway: "gateway";
|
|
6223
|
+
"event-config": "event-config";
|
|
6224
|
+
infrastructure: "infrastructure";
|
|
6225
|
+
pipeline: "pipeline";
|
|
6226
|
+
migration: "migration";
|
|
6227
|
+
diagram: "diagram";
|
|
6228
|
+
document: "document";
|
|
6229
|
+
export: "export";
|
|
6230
|
+
manual: "manual";
|
|
6231
|
+
}>, z.ZodEnum<{
|
|
6232
|
+
artifact: "artifact";
|
|
6233
|
+
catalog: "catalog";
|
|
6234
|
+
rule: "rule";
|
|
6235
|
+
}>]>;
|
|
6236
|
+
record: z.ZodOptional<z.ZodString>;
|
|
6237
|
+
path: z.ZodOptional<z.ZodString>;
|
|
6238
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6239
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6240
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
6241
|
+
}, z.core.$strict>>;
|
|
6242
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
6243
|
+
text: z.ZodString;
|
|
6244
|
+
owner: z.ZodString;
|
|
6245
|
+
}, z.core.$strict>>;
|
|
6246
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
6247
|
+
question: z.ZodString;
|
|
6248
|
+
quote: z.ZodString;
|
|
6249
|
+
}, z.core.$strict>>;
|
|
6250
|
+
waivable: z.ZodBoolean;
|
|
6251
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
6252
|
+
open: "open";
|
|
6253
|
+
applied: "applied";
|
|
6254
|
+
dismissed: "dismissed";
|
|
6255
|
+
waived: "waived";
|
|
6256
|
+
asked: "asked";
|
|
6257
|
+
}>>;
|
|
6258
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
6259
|
+
action: z.ZodEnum<{
|
|
6260
|
+
apply: "apply";
|
|
6261
|
+
"edit-and-apply": "edit-and-apply";
|
|
6262
|
+
"not-relevant": "not-relevant";
|
|
6263
|
+
waive: "waive";
|
|
6264
|
+
ask: "ask";
|
|
6265
|
+
}>;
|
|
6266
|
+
by: z.ZodString;
|
|
6267
|
+
at: z.ZodISODateTime;
|
|
6268
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
6269
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
6270
|
+
}, z.core.$strict>>;
|
|
6271
|
+
createdAt: z.ZodISODateTime;
|
|
6272
|
+
}, z.core.$strict>;
|
|
6273
|
+
file: z.ZodString;
|
|
6274
|
+
options: z.ZodObject<{
|
|
6275
|
+
fix: z.ZodString;
|
|
6276
|
+
apply: z.ZodBoolean;
|
|
6277
|
+
dismiss: z.ZodBoolean;
|
|
6278
|
+
waive: z.ZodBoolean;
|
|
6279
|
+
ask: z.ZodOptional<z.ZodObject<{
|
|
6280
|
+
text: z.ZodString;
|
|
6281
|
+
owner: z.ZodString;
|
|
6282
|
+
}, z.core.$strip>>;
|
|
6283
|
+
}, z.core.$strip>;
|
|
6284
|
+
comments: z.ZodArray<z.ZodObject<{
|
|
6285
|
+
question: z.ZodString;
|
|
6286
|
+
text: z.ZodString;
|
|
6287
|
+
by: z.ZodString;
|
|
6288
|
+
at: z.ZodString;
|
|
6289
|
+
read: z.ZodBoolean;
|
|
6290
|
+
}, z.core.$strip>>;
|
|
6291
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6292
|
+
claim: z.ZodEnum<{
|
|
6293
|
+
fixed: "fixed";
|
|
6294
|
+
"not-relevant": "not-relevant";
|
|
6295
|
+
}>;
|
|
6296
|
+
by: z.ZodString;
|
|
6297
|
+
at: z.ZodString;
|
|
6298
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
6299
|
+
}, z.core.$strip>>;
|
|
6300
|
+
}, z.core.$strip>;
|
|
6301
|
+
assistantWrites: z.ZodBoolean;
|
|
6302
|
+
edit: z.ZodOptional<z.ZodObject<{
|
|
6303
|
+
artifact: z.ZodString;
|
|
6304
|
+
file: z.ZodOptional<z.ZodString>;
|
|
6305
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6306
|
+
}, z.core.$strip>>;
|
|
6307
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6308
|
+
kind: z.ZodLiteral<"question">;
|
|
6309
|
+
at: z.ZodString;
|
|
6310
|
+
question: z.ZodObject<{
|
|
6311
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
6312
|
+
id: z.ZodString;
|
|
6313
|
+
askedBy: z.ZodObject<{
|
|
6314
|
+
step: z.ZodString;
|
|
6315
|
+
command: z.ZodString;
|
|
6316
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6317
|
+
at: z.ZodISODateTime;
|
|
6318
|
+
}, z.core.$strict>;
|
|
6319
|
+
alsoAskedBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6320
|
+
step: z.ZodString;
|
|
6321
|
+
command: z.ZodString;
|
|
6322
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6323
|
+
at: z.ZodISODateTime;
|
|
6324
|
+
rerun: z.ZodString;
|
|
6325
|
+
}, z.core.$strict>>>;
|
|
6326
|
+
repo: z.ZodString;
|
|
6327
|
+
question: z.ZodString;
|
|
6328
|
+
options: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
6329
|
+
label: z.ZodString;
|
|
6330
|
+
means: z.ZodString;
|
|
6331
|
+
changes: z.ZodString;
|
|
6332
|
+
}, z.core.$strict>>>;
|
|
6333
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6334
|
+
scope: z.ZodObject<{
|
|
6335
|
+
level: z.ZodEnum<{
|
|
6336
|
+
repo: "repo";
|
|
6337
|
+
"repo-type": "repo-type";
|
|
6338
|
+
}>;
|
|
6339
|
+
id: z.ZodString;
|
|
6340
|
+
}, z.core.$strict>;
|
|
6341
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
6342
|
+
product: "product";
|
|
6343
|
+
architecture: "architecture";
|
|
6344
|
+
delivery: "delivery";
|
|
6345
|
+
analysis: "analysis";
|
|
6346
|
+
}>>;
|
|
6347
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
6348
|
+
business: "business";
|
|
6349
|
+
delivery: "delivery";
|
|
6350
|
+
design: "design";
|
|
6351
|
+
}>>;
|
|
6352
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
6353
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
6354
|
+
product: "product";
|
|
6355
|
+
architecture: "architecture";
|
|
6356
|
+
delivery: "delivery";
|
|
6357
|
+
analysis: "analysis";
|
|
6358
|
+
}>>;
|
|
6359
|
+
by: z.ZodString;
|
|
6360
|
+
at: z.ZodISODateTime;
|
|
6361
|
+
}, z.core.$strict>>;
|
|
6362
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
6363
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
6364
|
+
change: z.ZodString;
|
|
6365
|
+
gate: z.ZodString;
|
|
6366
|
+
round: z.ZodNumber;
|
|
6367
|
+
id: z.ZodString;
|
|
6368
|
+
}, z.core.$strict>>;
|
|
6369
|
+
state: z.ZodEnum<{
|
|
6370
|
+
retired: "retired";
|
|
6371
|
+
open: "open";
|
|
6372
|
+
answered: "answered";
|
|
6373
|
+
}>;
|
|
6374
|
+
rerun: z.ZodString;
|
|
6375
|
+
answer: z.ZodOptional<z.ZodObject<{
|
|
6376
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6377
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6378
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6379
|
+
kind: z.ZodLiteral<"ai">;
|
|
6380
|
+
runtime: z.ZodEnum<{
|
|
6381
|
+
"hand-off": "hand-off";
|
|
6382
|
+
"copilot-acp": "copilot-acp";
|
|
6383
|
+
}>;
|
|
6384
|
+
run: z.ZodString;
|
|
6385
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6386
|
+
confident: "confident";
|
|
6387
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6388
|
+
"person-rule": "person-rule";
|
|
6389
|
+
}>>;
|
|
6390
|
+
}, z.core.$strict>]>;
|
|
6391
|
+
at: z.ZodISODateTime;
|
|
6392
|
+
scope: z.ZodObject<{
|
|
6393
|
+
level: z.ZodEnum<{
|
|
6394
|
+
repo: "repo";
|
|
6395
|
+
"repo-type": "repo-type";
|
|
6396
|
+
}>;
|
|
6397
|
+
id: z.ZodString;
|
|
6398
|
+
}, z.core.$strict>;
|
|
6399
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6400
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6401
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6402
|
+
by: z.ZodString;
|
|
6403
|
+
at: z.ZodISODateTime;
|
|
6404
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6405
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6406
|
+
file: z.ZodString;
|
|
6407
|
+
line: z.ZodNumber;
|
|
6408
|
+
quote: z.ZodString;
|
|
6409
|
+
}, z.core.$strict>>;
|
|
6410
|
+
}, z.core.$strict>>;
|
|
6411
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6412
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6413
|
+
from: z.ZodString;
|
|
6414
|
+
match: z.ZodString;
|
|
6415
|
+
}, z.core.$strict>>;
|
|
6416
|
+
}, z.core.$strict>>;
|
|
6417
|
+
retired: z.ZodOptional<z.ZodObject<{
|
|
6418
|
+
at: z.ZodISODateTime;
|
|
6419
|
+
why: z.ZodString;
|
|
6420
|
+
replacedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6421
|
+
}, z.core.$strict>>;
|
|
6422
|
+
reopened: z.ZodOptional<z.ZodObject<{
|
|
6423
|
+
at: z.ZodISODateTime;
|
|
6424
|
+
why: z.ZodString;
|
|
6425
|
+
answer: z.ZodObject<{
|
|
6426
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6427
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6428
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6429
|
+
kind: z.ZodLiteral<"ai">;
|
|
6430
|
+
runtime: z.ZodEnum<{
|
|
6431
|
+
"hand-off": "hand-off";
|
|
6432
|
+
"copilot-acp": "copilot-acp";
|
|
6433
|
+
}>;
|
|
6434
|
+
run: z.ZodString;
|
|
6435
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6436
|
+
confident: "confident";
|
|
6437
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6438
|
+
"person-rule": "person-rule";
|
|
6439
|
+
}>>;
|
|
6440
|
+
}, z.core.$strict>]>;
|
|
6441
|
+
at: z.ZodISODateTime;
|
|
6442
|
+
scope: z.ZodObject<{
|
|
6443
|
+
level: z.ZodEnum<{
|
|
6444
|
+
repo: "repo";
|
|
6445
|
+
"repo-type": "repo-type";
|
|
6446
|
+
}>;
|
|
6447
|
+
id: z.ZodString;
|
|
6448
|
+
}, z.core.$strict>;
|
|
6449
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6450
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6451
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6452
|
+
by: z.ZodString;
|
|
6453
|
+
at: z.ZodISODateTime;
|
|
6454
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6455
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6456
|
+
file: z.ZodString;
|
|
6457
|
+
line: z.ZodNumber;
|
|
6458
|
+
quote: z.ZodString;
|
|
6459
|
+
}, z.core.$strict>>;
|
|
6460
|
+
}, z.core.$strict>>;
|
|
6461
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6462
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6463
|
+
from: z.ZodString;
|
|
6464
|
+
match: z.ZodString;
|
|
6465
|
+
}, z.core.$strict>>;
|
|
6466
|
+
}, z.core.$strict>;
|
|
6467
|
+
}, z.core.$strict>>;
|
|
6468
|
+
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6469
|
+
id: z.ZodString;
|
|
6470
|
+
verdict: z.ZodEnum<{
|
|
6471
|
+
unsure: "unsure";
|
|
6472
|
+
narrower: "narrower";
|
|
6473
|
+
}>;
|
|
6474
|
+
judgment: z.ZodOptional<z.ZodString>;
|
|
6475
|
+
}, z.core.$strict>>>;
|
|
6476
|
+
}, z.core.$strict>;
|
|
6477
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6478
|
+
kind: z.ZodLiteral<"reply">;
|
|
6479
|
+
at: z.ZodString;
|
|
6480
|
+
text: z.ZodString;
|
|
6481
|
+
by: z.ZodString;
|
|
6482
|
+
read: z.ZodBoolean;
|
|
6483
|
+
about: z.ZodOptional<z.ZodString>;
|
|
6484
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6485
|
+
kind: z.ZodLiteral<"correction">;
|
|
6486
|
+
at: z.ZodString;
|
|
6487
|
+
text: z.ZodString;
|
|
6488
|
+
label: z.ZodString;
|
|
6489
|
+
by: z.ZodString;
|
|
6490
|
+
state: z.ZodString;
|
|
6491
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6492
|
+
kind: z.ZodLiteral<"dropped">;
|
|
6493
|
+
at: z.ZodString;
|
|
6494
|
+
key: z.ZodString;
|
|
6495
|
+
question: z.ZodString;
|
|
6496
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6497
|
+
nearest: z.ZodOptional<z.ZodString>;
|
|
6498
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6499
|
+
kind: z.ZodLiteral<"note">;
|
|
6500
|
+
at: z.ZodString;
|
|
6501
|
+
text: z.ZodString;
|
|
6502
|
+
}, z.core.$strip>], "kind">>;
|
|
6503
|
+
waiting: z.ZodOptional<z.ZodObject<{
|
|
6504
|
+
runId: z.ZodString;
|
|
6505
|
+
prompt: z.ZodString;
|
|
6506
|
+
}, z.core.$strip>>;
|
|
6507
|
+
step: z.ZodArray<z.ZodString>;
|
|
6508
|
+
reply: z.ZodObject<{
|
|
6509
|
+
open: z.ZodBoolean;
|
|
6510
|
+
why: z.ZodOptional<z.ZodString>;
|
|
6511
|
+
}, z.core.$strip>;
|
|
6512
|
+
problems: z.ZodArray<z.ZodObject<{
|
|
6513
|
+
file: z.ZodString;
|
|
6514
|
+
message: z.ZodString;
|
|
6515
|
+
}, z.core.$strip>>;
|
|
6516
|
+
}, z.core.$strip>;
|
|
6517
|
+
export declare const StageThreadPost: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
6518
|
+
kind: z.ZodLiteral<"reply">;
|
|
6519
|
+
text: z.ZodString;
|
|
6520
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
6521
|
+
kind: z.ZodLiteral<"finding">;
|
|
6522
|
+
finding: z.ZodString;
|
|
6523
|
+
gate: z.ZodOptional<z.ZodString>;
|
|
6524
|
+
text: z.ZodString;
|
|
6525
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
6526
|
+
kind: z.ZodLiteral<"keep">;
|
|
6527
|
+
key: z.ZodString;
|
|
6528
|
+
}, z.core.$strict>], "kind">;
|
|
6529
|
+
export declare const StageThreadPostResult: z.ZodObject<{
|
|
6530
|
+
files: z.ZodArray<z.ZodString>;
|
|
6531
|
+
thread: z.ZodObject<{
|
|
6532
|
+
change: z.ZodString;
|
|
6533
|
+
stage: z.ZodEnum<{
|
|
6534
|
+
small: "small";
|
|
6535
|
+
architecture: "architecture";
|
|
6536
|
+
proposal: "proposal";
|
|
6537
|
+
stories: "stories";
|
|
6538
|
+
feature: "feature";
|
|
6539
|
+
}>;
|
|
6540
|
+
state: z.ZodEnum<{
|
|
6541
|
+
"not-started": "not-started";
|
|
6542
|
+
done: "done";
|
|
6543
|
+
questions: "questions";
|
|
6544
|
+
waiting: "waiting";
|
|
6545
|
+
stopped: "stopped";
|
|
6546
|
+
drafting: "drafting";
|
|
6547
|
+
}>;
|
|
6548
|
+
headline: z.ZodString;
|
|
6549
|
+
items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
6550
|
+
kind: z.ZodLiteral<"prompt">;
|
|
6551
|
+
at: z.ZodString;
|
|
6552
|
+
runId: z.ZodString;
|
|
6553
|
+
who: z.ZodEnum<{
|
|
6554
|
+
critic: "critic";
|
|
6555
|
+
drafter: "drafter";
|
|
6556
|
+
}>;
|
|
6557
|
+
prompt: z.ZodString;
|
|
6558
|
+
state: z.ZodEnum<{
|
|
6559
|
+
failed: "failed";
|
|
6560
|
+
prepared: "prepared";
|
|
6561
|
+
waiting: "waiting";
|
|
6562
|
+
produced: "produced";
|
|
6563
|
+
validated: "validated";
|
|
6564
|
+
cancelled: "cancelled";
|
|
6565
|
+
}>;
|
|
6566
|
+
details: z.ZodObject<{
|
|
6567
|
+
agent: z.ZodString;
|
|
6568
|
+
runtime: z.ZodString;
|
|
6569
|
+
promptPath: z.ZodString;
|
|
6570
|
+
output: z.ZodOptional<z.ZodString>;
|
|
6571
|
+
promptTokens: z.ZodOptional<z.ZodNumber>;
|
|
6572
|
+
model: z.ZodOptional<z.ZodString>;
|
|
6573
|
+
attempt: z.ZodNumber;
|
|
6574
|
+
}, z.core.$strip>;
|
|
6575
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6576
|
+
kind: z.ZodLiteral<"answer">;
|
|
6577
|
+
at: z.ZodString;
|
|
6578
|
+
runId: z.ZodString;
|
|
6579
|
+
who: z.ZodEnum<{
|
|
6580
|
+
critic: "critic";
|
|
6581
|
+
drafter: "drafter";
|
|
6582
|
+
}>;
|
|
6583
|
+
checked: z.ZodEnum<{
|
|
6584
|
+
failed: "failed";
|
|
6585
|
+
passed: "passed";
|
|
6586
|
+
checking: "checking";
|
|
6587
|
+
}>;
|
|
6588
|
+
by: z.ZodOptional<z.ZodEnum<{
|
|
6589
|
+
person: "person";
|
|
6590
|
+
app: "app";
|
|
6591
|
+
}>>;
|
|
6592
|
+
summary: z.ZodArray<z.ZodString>;
|
|
6593
|
+
problems: z.ZodArray<z.ZodString>;
|
|
6594
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6595
|
+
kind: z.ZodLiteral<"changed">;
|
|
6596
|
+
at: z.ZodString;
|
|
6597
|
+
files: z.ZodArray<z.ZodString>;
|
|
6598
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6599
|
+
kind: z.ZodLiteral<"finding">;
|
|
6600
|
+
at: z.ZodString;
|
|
6601
|
+
view: z.ZodObject<{
|
|
6602
|
+
finding: z.ZodObject<{
|
|
6603
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
6604
|
+
id: z.ZodString;
|
|
6605
|
+
kind: z.ZodEnum<{
|
|
6606
|
+
issue: "issue";
|
|
6607
|
+
"knowledge-gap": "knowledge-gap";
|
|
6608
|
+
}>;
|
|
6609
|
+
change: z.ZodString;
|
|
6610
|
+
gate: z.ZodString;
|
|
6611
|
+
round: z.ZodNumber;
|
|
6612
|
+
rule: z.ZodString;
|
|
6613
|
+
layer: z.ZodEnum<{
|
|
6614
|
+
team: "team";
|
|
6615
|
+
constitution: "constitution";
|
|
6616
|
+
org: "org";
|
|
6617
|
+
}>;
|
|
6618
|
+
lens: z.ZodEnum<{
|
|
6619
|
+
release: "release";
|
|
6620
|
+
true: "true";
|
|
6621
|
+
complete: "complete";
|
|
6622
|
+
safe: "safe";
|
|
6623
|
+
ship: "ship";
|
|
6624
|
+
business: "business";
|
|
6625
|
+
architecture: "architecture";
|
|
6626
|
+
story: "story";
|
|
6627
|
+
ux: "ux";
|
|
6628
|
+
delivery: "delivery";
|
|
6629
|
+
"code-and-test": "code-and-test";
|
|
6630
|
+
}>;
|
|
6631
|
+
severity: z.ZodEnum<{
|
|
6632
|
+
blocking: "blocking";
|
|
6633
|
+
gap: "gap";
|
|
6634
|
+
risk: "risk";
|
|
6635
|
+
idea: "idea";
|
|
6636
|
+
}>;
|
|
6637
|
+
artifact: z.ZodString;
|
|
6638
|
+
locator: z.ZodObject<{
|
|
6639
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6640
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
6641
|
+
record: z.ZodOptional<z.ZodString>;
|
|
6642
|
+
field: z.ZodOptional<z.ZodString>;
|
|
6643
|
+
}, z.core.$strict>;
|
|
6644
|
+
summary: z.ZodString;
|
|
6645
|
+
why: z.ZodString;
|
|
6646
|
+
fix: z.ZodObject<{
|
|
6647
|
+
text: z.ZodString;
|
|
6648
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
6649
|
+
}, z.core.$strict>;
|
|
6650
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
6651
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
6652
|
+
code: "code";
|
|
6653
|
+
config: "config";
|
|
6654
|
+
spec: "spec";
|
|
6655
|
+
gateway: "gateway";
|
|
6656
|
+
"event-config": "event-config";
|
|
6657
|
+
infrastructure: "infrastructure";
|
|
6658
|
+
pipeline: "pipeline";
|
|
6659
|
+
migration: "migration";
|
|
6660
|
+
diagram: "diagram";
|
|
6661
|
+
document: "document";
|
|
6662
|
+
export: "export";
|
|
6663
|
+
manual: "manual";
|
|
6664
|
+
}>, z.ZodEnum<{
|
|
6665
|
+
artifact: "artifact";
|
|
6666
|
+
catalog: "catalog";
|
|
6667
|
+
rule: "rule";
|
|
6668
|
+
}>]>;
|
|
6669
|
+
record: z.ZodOptional<z.ZodString>;
|
|
6670
|
+
path: z.ZodOptional<z.ZodString>;
|
|
6671
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6672
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6673
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
6674
|
+
}, z.core.$strict>>;
|
|
6675
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
6676
|
+
text: z.ZodString;
|
|
6677
|
+
owner: z.ZodString;
|
|
6678
|
+
}, z.core.$strict>>;
|
|
6679
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
6680
|
+
question: z.ZodString;
|
|
6681
|
+
quote: z.ZodString;
|
|
6682
|
+
}, z.core.$strict>>;
|
|
6683
|
+
waivable: z.ZodBoolean;
|
|
6684
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
6685
|
+
open: "open";
|
|
6686
|
+
applied: "applied";
|
|
6687
|
+
dismissed: "dismissed";
|
|
6688
|
+
waived: "waived";
|
|
6689
|
+
asked: "asked";
|
|
6690
|
+
}>>;
|
|
6691
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
6692
|
+
action: z.ZodEnum<{
|
|
6693
|
+
apply: "apply";
|
|
6694
|
+
"edit-and-apply": "edit-and-apply";
|
|
6695
|
+
"not-relevant": "not-relevant";
|
|
6696
|
+
waive: "waive";
|
|
6697
|
+
ask: "ask";
|
|
6698
|
+
}>;
|
|
6699
|
+
by: z.ZodString;
|
|
6700
|
+
at: z.ZodISODateTime;
|
|
6701
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
6702
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
6703
|
+
}, z.core.$strict>>;
|
|
6704
|
+
createdAt: z.ZodISODateTime;
|
|
6705
|
+
}, z.core.$strict>;
|
|
6706
|
+
file: z.ZodString;
|
|
6707
|
+
options: z.ZodObject<{
|
|
6708
|
+
fix: z.ZodString;
|
|
6709
|
+
apply: z.ZodBoolean;
|
|
6710
|
+
dismiss: z.ZodBoolean;
|
|
6711
|
+
waive: z.ZodBoolean;
|
|
6712
|
+
ask: z.ZodOptional<z.ZodObject<{
|
|
6713
|
+
text: z.ZodString;
|
|
6714
|
+
owner: z.ZodString;
|
|
6715
|
+
}, z.core.$strip>>;
|
|
6716
|
+
}, z.core.$strip>;
|
|
6717
|
+
comments: z.ZodArray<z.ZodObject<{
|
|
6718
|
+
question: z.ZodString;
|
|
6719
|
+
text: z.ZodString;
|
|
6720
|
+
by: z.ZodString;
|
|
6721
|
+
at: z.ZodString;
|
|
6722
|
+
read: z.ZodBoolean;
|
|
6723
|
+
}, z.core.$strip>>;
|
|
6724
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6725
|
+
claim: z.ZodEnum<{
|
|
6726
|
+
fixed: "fixed";
|
|
6727
|
+
"not-relevant": "not-relevant";
|
|
6728
|
+
}>;
|
|
6729
|
+
by: z.ZodString;
|
|
6730
|
+
at: z.ZodString;
|
|
6731
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
6732
|
+
}, z.core.$strip>>;
|
|
6733
|
+
}, z.core.$strip>;
|
|
6734
|
+
assistantWrites: z.ZodBoolean;
|
|
6735
|
+
edit: z.ZodOptional<z.ZodObject<{
|
|
6736
|
+
artifact: z.ZodString;
|
|
6737
|
+
file: z.ZodOptional<z.ZodString>;
|
|
6738
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
6739
|
+
}, z.core.$strip>>;
|
|
6740
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6741
|
+
kind: z.ZodLiteral<"question">;
|
|
6742
|
+
at: z.ZodString;
|
|
6743
|
+
question: z.ZodObject<{
|
|
6744
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
6745
|
+
id: z.ZodString;
|
|
6746
|
+
askedBy: z.ZodObject<{
|
|
6747
|
+
step: z.ZodString;
|
|
6748
|
+
command: z.ZodString;
|
|
6749
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6750
|
+
at: z.ZodISODateTime;
|
|
6751
|
+
}, z.core.$strict>;
|
|
6752
|
+
alsoAskedBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6753
|
+
step: z.ZodString;
|
|
6754
|
+
command: z.ZodString;
|
|
6755
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6756
|
+
at: z.ZodISODateTime;
|
|
6757
|
+
rerun: z.ZodString;
|
|
6758
|
+
}, z.core.$strict>>>;
|
|
6759
|
+
repo: z.ZodString;
|
|
6760
|
+
question: z.ZodString;
|
|
6761
|
+
options: z.ZodDefault<z.ZodArray<z.ZodObject<{
|
|
6762
|
+
label: z.ZodString;
|
|
6763
|
+
means: z.ZodString;
|
|
6764
|
+
changes: z.ZodString;
|
|
6765
|
+
}, z.core.$strict>>>;
|
|
6766
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6767
|
+
scope: z.ZodObject<{
|
|
6768
|
+
level: z.ZodEnum<{
|
|
6769
|
+
repo: "repo";
|
|
6770
|
+
"repo-type": "repo-type";
|
|
6771
|
+
}>;
|
|
6772
|
+
id: z.ZodString;
|
|
6773
|
+
}, z.core.$strict>;
|
|
6774
|
+
role: z.ZodOptional<z.ZodEnum<{
|
|
6775
|
+
product: "product";
|
|
6776
|
+
architecture: "architecture";
|
|
6777
|
+
delivery: "delivery";
|
|
6778
|
+
analysis: "analysis";
|
|
6779
|
+
}>>;
|
|
6780
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
6781
|
+
business: "business";
|
|
6782
|
+
delivery: "delivery";
|
|
6783
|
+
design: "design";
|
|
6784
|
+
}>>;
|
|
6785
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
6786
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
6787
|
+
product: "product";
|
|
6788
|
+
architecture: "architecture";
|
|
6789
|
+
delivery: "delivery";
|
|
6790
|
+
analysis: "analysis";
|
|
6791
|
+
}>>;
|
|
6792
|
+
by: z.ZodString;
|
|
6793
|
+
at: z.ZodISODateTime;
|
|
6794
|
+
}, z.core.$strict>>;
|
|
6795
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
6796
|
+
finding: z.ZodOptional<z.ZodObject<{
|
|
6797
|
+
change: z.ZodString;
|
|
6798
|
+
gate: z.ZodString;
|
|
6799
|
+
round: z.ZodNumber;
|
|
6800
|
+
id: z.ZodString;
|
|
6801
|
+
}, z.core.$strict>>;
|
|
6802
|
+
state: z.ZodEnum<{
|
|
6803
|
+
retired: "retired";
|
|
6804
|
+
open: "open";
|
|
6805
|
+
answered: "answered";
|
|
6806
|
+
}>;
|
|
6807
|
+
rerun: z.ZodString;
|
|
6808
|
+
answer: z.ZodOptional<z.ZodObject<{
|
|
6809
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6810
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6811
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6812
|
+
kind: z.ZodLiteral<"ai">;
|
|
6813
|
+
runtime: z.ZodEnum<{
|
|
6814
|
+
"hand-off": "hand-off";
|
|
6815
|
+
"copilot-acp": "copilot-acp";
|
|
6816
|
+
}>;
|
|
6817
|
+
run: z.ZodString;
|
|
6818
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6819
|
+
confident: "confident";
|
|
6820
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6821
|
+
"person-rule": "person-rule";
|
|
6822
|
+
}>>;
|
|
6823
|
+
}, z.core.$strict>]>;
|
|
6824
|
+
at: z.ZodISODateTime;
|
|
6825
|
+
scope: z.ZodObject<{
|
|
6826
|
+
level: z.ZodEnum<{
|
|
6827
|
+
repo: "repo";
|
|
6828
|
+
"repo-type": "repo-type";
|
|
6829
|
+
}>;
|
|
6830
|
+
id: z.ZodString;
|
|
6831
|
+
}, z.core.$strict>;
|
|
6832
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6833
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6834
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6835
|
+
by: z.ZodString;
|
|
6836
|
+
at: z.ZodISODateTime;
|
|
6837
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6838
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6839
|
+
file: z.ZodString;
|
|
6840
|
+
line: z.ZodNumber;
|
|
6841
|
+
quote: z.ZodString;
|
|
6842
|
+
}, z.core.$strict>>;
|
|
6843
|
+
}, z.core.$strict>>;
|
|
6844
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6845
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6846
|
+
from: z.ZodString;
|
|
6847
|
+
match: z.ZodString;
|
|
6848
|
+
}, z.core.$strict>>;
|
|
6849
|
+
}, z.core.$strict>>;
|
|
6850
|
+
retired: z.ZodOptional<z.ZodObject<{
|
|
6851
|
+
at: z.ZodISODateTime;
|
|
6852
|
+
why: z.ZodString;
|
|
6853
|
+
replacedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6854
|
+
}, z.core.$strict>>;
|
|
6855
|
+
reopened: z.ZodOptional<z.ZodObject<{
|
|
6856
|
+
at: z.ZodISODateTime;
|
|
6857
|
+
why: z.ZodString;
|
|
6858
|
+
answer: z.ZodObject<{
|
|
6859
|
+
option: z.ZodOptional<z.ZodNumber>;
|
|
6860
|
+
text: z.ZodOptional<z.ZodString>;
|
|
6861
|
+
by: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
6862
|
+
kind: z.ZodLiteral<"ai">;
|
|
6863
|
+
runtime: z.ZodEnum<{
|
|
6864
|
+
"hand-off": "hand-off";
|
|
6865
|
+
"copilot-acp": "copilot-acp";
|
|
6866
|
+
}>;
|
|
6867
|
+
run: z.ZodString;
|
|
6868
|
+
bar: z.ZodOptional<z.ZodEnum<{
|
|
6869
|
+
confident: "confident";
|
|
6870
|
+
"agrees-with-shapes": "agrees-with-shapes";
|
|
6871
|
+
"person-rule": "person-rule";
|
|
6872
|
+
}>>;
|
|
6873
|
+
}, z.core.$strict>]>;
|
|
6874
|
+
at: z.ZodISODateTime;
|
|
6875
|
+
scope: z.ZodObject<{
|
|
6876
|
+
level: z.ZodEnum<{
|
|
6877
|
+
repo: "repo";
|
|
6878
|
+
"repo-type": "repo-type";
|
|
6879
|
+
}>;
|
|
6880
|
+
id: z.ZodString;
|
|
6881
|
+
}, z.core.$strict>;
|
|
6882
|
+
skill: z.ZodOptional<z.ZodString>;
|
|
6883
|
+
match: z.ZodOptional<z.ZodString>;
|
|
6884
|
+
proposal: z.ZodOptional<z.ZodObject<{
|
|
6885
|
+
by: z.ZodString;
|
|
6886
|
+
at: z.ZodISODateTime;
|
|
6887
|
+
cites: z.ZodArray<z.ZodObject<{
|
|
6888
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
6889
|
+
file: z.ZodString;
|
|
6890
|
+
line: z.ZodNumber;
|
|
6891
|
+
quote: z.ZodString;
|
|
6892
|
+
}, z.core.$strict>>;
|
|
6893
|
+
}, z.core.$strict>>;
|
|
6894
|
+
batch: z.ZodOptional<z.ZodString>;
|
|
6895
|
+
rule: z.ZodOptional<z.ZodObject<{
|
|
6896
|
+
from: z.ZodString;
|
|
6897
|
+
match: z.ZodString;
|
|
6898
|
+
}, z.core.$strict>>;
|
|
6899
|
+
}, z.core.$strict>;
|
|
6900
|
+
}, z.core.$strict>>;
|
|
6901
|
+
related: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
6902
|
+
id: z.ZodString;
|
|
6903
|
+
verdict: z.ZodEnum<{
|
|
6904
|
+
unsure: "unsure";
|
|
6905
|
+
narrower: "narrower";
|
|
6906
|
+
}>;
|
|
6907
|
+
judgment: z.ZodOptional<z.ZodString>;
|
|
6908
|
+
}, z.core.$strict>>>;
|
|
6909
|
+
}, z.core.$strict>;
|
|
6910
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6911
|
+
kind: z.ZodLiteral<"reply">;
|
|
6912
|
+
at: z.ZodString;
|
|
6913
|
+
text: z.ZodString;
|
|
6914
|
+
by: z.ZodString;
|
|
6915
|
+
read: z.ZodBoolean;
|
|
6916
|
+
about: z.ZodOptional<z.ZodString>;
|
|
6917
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6918
|
+
kind: z.ZodLiteral<"correction">;
|
|
6919
|
+
at: z.ZodString;
|
|
6920
|
+
text: z.ZodString;
|
|
6921
|
+
label: z.ZodString;
|
|
6922
|
+
by: z.ZodString;
|
|
6923
|
+
state: z.ZodString;
|
|
6924
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6925
|
+
kind: z.ZodLiteral<"dropped">;
|
|
6926
|
+
at: z.ZodString;
|
|
6927
|
+
key: z.ZodString;
|
|
6928
|
+
question: z.ZodString;
|
|
6929
|
+
evidence: z.ZodArray<z.ZodString>;
|
|
6930
|
+
nearest: z.ZodOptional<z.ZodString>;
|
|
6931
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
6932
|
+
kind: z.ZodLiteral<"note">;
|
|
6933
|
+
at: z.ZodString;
|
|
6934
|
+
text: z.ZodString;
|
|
6935
|
+
}, z.core.$strip>], "kind">>;
|
|
6936
|
+
waiting: z.ZodOptional<z.ZodObject<{
|
|
6937
|
+
runId: z.ZodString;
|
|
6938
|
+
prompt: z.ZodString;
|
|
6939
|
+
}, z.core.$strip>>;
|
|
6940
|
+
step: z.ZodArray<z.ZodString>;
|
|
6941
|
+
reply: z.ZodObject<{
|
|
6942
|
+
open: z.ZodBoolean;
|
|
6943
|
+
why: z.ZodOptional<z.ZodString>;
|
|
6944
|
+
}, z.core.$strip>;
|
|
6945
|
+
problems: z.ZodArray<z.ZodObject<{
|
|
6946
|
+
file: z.ZodString;
|
|
6947
|
+
message: z.ZodString;
|
|
6948
|
+
}, z.core.$strip>>;
|
|
6949
|
+
}, z.core.$strip>;
|
|
6950
|
+
}, z.core.$strip>;
|
|
6951
|
+
export type ThreadStageT = z.infer<typeof ThreadStage>;
|
|
6952
|
+
export type ThreadItemT = z.infer<typeof ThreadItem>;
|
|
6953
|
+
export type StageThreadViewT = z.infer<typeof StageThreadView>;
|
|
6954
|
+
export type StageThreadPostT = z.infer<typeof StageThreadPost>;
|
|
6955
|
+
export type StageThreadPostResultT = z.infer<typeof StageThreadPostResult>;
|
|
6956
|
+
export type StageFindingViewT = z.infer<typeof StageFindingView>;
|
|
6957
|
+
export type StageCommentResultT = z.infer<typeof StageCommentResult>;
|
|
6958
|
+
/**
|
|
6959
|
+
* 2.80.0 (ADR 0181, stage drafts): AI decides first, a person corrects, and the AI corrects the
|
|
6960
|
+
* rest like it. A page's stage drafts (Feature design: feature.md and proposal.md; Architecture:
|
|
6961
|
+
* the target flows, design.md and data.md; Stories: the stories and the specs; Tasks: tasks.md),
|
|
6962
|
+
* each with who wrote it last (`drafted`: the AI with its stage and run, from
|
|
6963
|
+
* `stage/drafted.yaml`, until a person saves it) and the items a person can correct. A
|
|
6964
|
+
* correction (`stage/corrections.yaml`) is read by the stage's next run as the person's word in
|
|
6965
|
+
* its brief; with `scope: similar` the run applies it to every item like it. After the run it is
|
|
6966
|
+
* `applied` when the draft changed its item (else `read`), and `touched` lists the other items
|
|
6967
|
+
* the draft changed for it. Kept on file either way.
|
|
6968
|
+
*/
|
|
6969
|
+
export declare const DRAFT_PAGES: readonly ["feature", "architecture", "stories", "tasks"];
|
|
6970
|
+
export declare const DraftPage: z.ZodEnum<{
|
|
6971
|
+
architecture: "architecture";
|
|
6972
|
+
stories: "stories";
|
|
6973
|
+
tasks: "tasks";
|
|
6974
|
+
feature: "feature";
|
|
6975
|
+
}>;
|
|
6976
|
+
export declare const DraftProvenance: z.ZodObject<{
|
|
6977
|
+
by: z.ZodEnum<{
|
|
6978
|
+
ai: "ai";
|
|
6979
|
+
person: "person";
|
|
6980
|
+
}>;
|
|
6981
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
6982
|
+
run: z.ZodOptional<z.ZodString>;
|
|
6983
|
+
who: z.ZodOptional<z.ZodString>;
|
|
6984
|
+
at: z.ZodOptional<z.ZodString>;
|
|
6985
|
+
}, z.core.$strip>;
|
|
6986
|
+
export declare const DraftItemView: z.ZodObject<{
|
|
6987
|
+
id: z.ZodString;
|
|
6988
|
+
label: z.ZodString;
|
|
6989
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6990
|
+
}, z.core.$strip>;
|
|
6991
|
+
export declare const DraftFileView: z.ZodObject<{
|
|
6992
|
+
file: z.ZodString;
|
|
6993
|
+
path: z.ZodString;
|
|
6994
|
+
stage: z.ZodString;
|
|
6995
|
+
drafted: z.ZodOptional<z.ZodObject<{
|
|
6996
|
+
by: z.ZodEnum<{
|
|
6997
|
+
ai: "ai";
|
|
6998
|
+
person: "person";
|
|
6999
|
+
}>;
|
|
7000
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
7001
|
+
run: z.ZodOptional<z.ZodString>;
|
|
7002
|
+
who: z.ZodOptional<z.ZodString>;
|
|
7003
|
+
at: z.ZodOptional<z.ZodString>;
|
|
7004
|
+
}, z.core.$strip>>;
|
|
7005
|
+
items: z.ZodArray<z.ZodObject<{
|
|
7006
|
+
id: z.ZodString;
|
|
7007
|
+
label: z.ZodString;
|
|
7008
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7009
|
+
}, z.core.$strip>>;
|
|
7010
|
+
}, z.core.$strip>;
|
|
7011
|
+
export declare const CorrectionView: z.ZodObject<{
|
|
7012
|
+
id: z.ZodString;
|
|
7013
|
+
stage: z.ZodString;
|
|
7014
|
+
file: z.ZodString;
|
|
7015
|
+
item: z.ZodOptional<z.ZodString>;
|
|
7016
|
+
label: z.ZodString;
|
|
7017
|
+
text: z.ZodString;
|
|
7018
|
+
scope: z.ZodEnum<{
|
|
7019
|
+
one: "one";
|
|
7020
|
+
similar: "similar";
|
|
7021
|
+
}>;
|
|
7022
|
+
like: z.ZodOptional<z.ZodString>;
|
|
7023
|
+
by: z.ZodString;
|
|
7024
|
+
at: z.ZodString;
|
|
7025
|
+
state: z.ZodEnum<{
|
|
7026
|
+
read: "read";
|
|
7027
|
+
applied: "applied";
|
|
7028
|
+
waiting: "waiting";
|
|
7029
|
+
}>;
|
|
7030
|
+
run: z.ZodOptional<z.ZodString>;
|
|
7031
|
+
iteration: z.ZodOptional<z.ZodNumber>;
|
|
7032
|
+
appliedAt: z.ZodOptional<z.ZodString>;
|
|
7033
|
+
touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7034
|
+
}, z.core.$strip>;
|
|
7035
|
+
export declare const StageDraftsView: z.ZodObject<{
|
|
7036
|
+
change: z.ZodString;
|
|
7037
|
+
page: z.ZodEnum<{
|
|
7038
|
+
architecture: "architecture";
|
|
7039
|
+
stories: "stories";
|
|
7040
|
+
tasks: "tasks";
|
|
7041
|
+
feature: "feature";
|
|
7042
|
+
}>;
|
|
7043
|
+
files: z.ZodArray<z.ZodObject<{
|
|
7044
|
+
file: z.ZodString;
|
|
7045
|
+
path: z.ZodString;
|
|
7046
|
+
stage: z.ZodString;
|
|
7047
|
+
drafted: z.ZodOptional<z.ZodObject<{
|
|
7048
|
+
by: z.ZodEnum<{
|
|
7049
|
+
ai: "ai";
|
|
7050
|
+
person: "person";
|
|
7051
|
+
}>;
|
|
7052
|
+
stage: z.ZodOptional<z.ZodString>;
|
|
7053
|
+
run: z.ZodOptional<z.ZodString>;
|
|
7054
|
+
who: z.ZodOptional<z.ZodString>;
|
|
7055
|
+
at: z.ZodOptional<z.ZodString>;
|
|
7056
|
+
}, z.core.$strip>>;
|
|
7057
|
+
items: z.ZodArray<z.ZodObject<{
|
|
7058
|
+
id: z.ZodString;
|
|
7059
|
+
label: z.ZodString;
|
|
7060
|
+
like: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
7061
|
+
}, z.core.$strip>>;
|
|
7062
|
+
}, z.core.$strip>>;
|
|
7063
|
+
corrections: z.ZodArray<z.ZodObject<{
|
|
7064
|
+
id: z.ZodString;
|
|
7065
|
+
stage: z.ZodString;
|
|
7066
|
+
file: z.ZodString;
|
|
7067
|
+
item: z.ZodOptional<z.ZodString>;
|
|
7068
|
+
label: z.ZodString;
|
|
7069
|
+
text: z.ZodString;
|
|
7070
|
+
scope: z.ZodEnum<{
|
|
7071
|
+
one: "one";
|
|
7072
|
+
similar: "similar";
|
|
7073
|
+
}>;
|
|
7074
|
+
like: z.ZodOptional<z.ZodString>;
|
|
7075
|
+
by: z.ZodString;
|
|
7076
|
+
at: z.ZodString;
|
|
7077
|
+
state: z.ZodEnum<{
|
|
7078
|
+
read: "read";
|
|
5191
7079
|
applied: "applied";
|
|
5192
7080
|
waiting: "waiting";
|
|
5193
7081
|
}>;
|
|
@@ -5682,8 +7570,8 @@ export declare const TargetFlowList: z.ZodObject<{
|
|
|
5682
7570
|
}, z.core.$strip>;
|
|
5683
7571
|
export declare const MergedStep: z.ZodObject<{
|
|
5684
7572
|
mark: z.ZodEnum<{
|
|
5685
|
-
added: "added";
|
|
5686
7573
|
same: "same";
|
|
7574
|
+
added: "added";
|
|
5687
7575
|
changed: "changed";
|
|
5688
7576
|
removed: "removed";
|
|
5689
7577
|
}>;
|
|
@@ -5848,8 +7736,8 @@ export declare const TargetFlowView: z.ZodObject<{
|
|
|
5848
7736
|
}, z.core.$strict>>;
|
|
5849
7737
|
steps: z.ZodArray<z.ZodObject<{
|
|
5850
7738
|
mark: z.ZodEnum<{
|
|
5851
|
-
added: "added";
|
|
5852
7739
|
same: "same";
|
|
7740
|
+
added: "added";
|
|
5853
7741
|
changed: "changed";
|
|
5854
7742
|
removed: "removed";
|
|
5855
7743
|
}>;
|
|
@@ -5961,8 +7849,8 @@ export declare const ChangeMap: z.ZodObject<{
|
|
|
5961
7849
|
system: "system";
|
|
5962
7850
|
component: "component";
|
|
5963
7851
|
table: "table";
|
|
5964
|
-
topic: "topic";
|
|
5965
7852
|
box: "box";
|
|
7853
|
+
topic: "topic";
|
|
5966
7854
|
}>;
|
|
5967
7855
|
boundary: z.ZodOptional<z.ZodEnum<{
|
|
5968
7856
|
product: "product";
|
|
@@ -6361,11 +8249,13 @@ export declare const Health: z.ZodObject<{
|
|
|
6361
8249
|
openspec: z.ZodOptional<z.ZodString>;
|
|
6362
8250
|
user: z.ZodString;
|
|
6363
8251
|
full: z.ZodOptional<z.ZodBoolean>;
|
|
8252
|
+
metarepo: z.ZodOptional<z.ZodBoolean>;
|
|
6364
8253
|
}, z.core.$strip>;
|
|
6365
8254
|
export declare const ScanRequest: z.ZodObject<{
|
|
6366
8255
|
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
6367
8256
|
full: z.ZodDefault<z.ZodBoolean>;
|
|
6368
8257
|
ref: z.ZodOptional<z.ZodString>;
|
|
8258
|
+
askAll: z.ZodOptional<z.ZodBoolean>;
|
|
6369
8259
|
}, z.core.$strict>;
|
|
6370
8260
|
/** ADR 0123: each repo's branches, as the Repos screen shows them. */
|
|
6371
8261
|
export declare const RepoBranchesView: z.ZodObject<{
|
|
@@ -6527,6 +8417,15 @@ export declare const ChangeCockpit: z.ZodObject<{
|
|
|
6527
8417
|
delivery: "delivery";
|
|
6528
8418
|
analysis: "analysis";
|
|
6529
8419
|
}>>>;
|
|
8420
|
+
waitsOn: z.ZodOptional<z.ZodLazy<z.ZodObject<{
|
|
8421
|
+
role: z.ZodString;
|
|
8422
|
+
people: z.ZodArray<z.ZodString>;
|
|
8423
|
+
because: z.ZodEnum<{
|
|
8424
|
+
phase: "phase";
|
|
8425
|
+
handoff: "handoff";
|
|
8426
|
+
}>;
|
|
8427
|
+
phase: z.ZodString;
|
|
8428
|
+
}, z.core.$strip>>>;
|
|
6530
8429
|
repos: z.ZodArray<z.ZodObject<{
|
|
6531
8430
|
id: z.ZodString;
|
|
6532
8431
|
branch: z.ZodString;
|
|
@@ -6552,10 +8451,10 @@ export declare const NewChangeRequest: z.ZodObject<{
|
|
|
6552
8451
|
export declare const ProposeScope: z.ZodEnum<{
|
|
6553
8452
|
"service-desk": "service-desk";
|
|
6554
8453
|
"org-pack": "org-pack";
|
|
8454
|
+
work: "work";
|
|
6555
8455
|
audit: "audit";
|
|
6556
|
-
corrections: "corrections";
|
|
6557
8456
|
answers: "answers";
|
|
6558
|
-
|
|
8457
|
+
corrections: "corrections";
|
|
6559
8458
|
"owner-answers": "owner-answers";
|
|
6560
8459
|
baseline: "baseline";
|
|
6561
8460
|
initiatives: "initiatives";
|
|
@@ -6565,10 +8464,10 @@ export declare const ProposePlanView: z.ZodObject<{
|
|
|
6565
8464
|
scope: z.ZodEnum<{
|
|
6566
8465
|
"service-desk": "service-desk";
|
|
6567
8466
|
"org-pack": "org-pack";
|
|
8467
|
+
work: "work";
|
|
6568
8468
|
audit: "audit";
|
|
6569
|
-
corrections: "corrections";
|
|
6570
8469
|
answers: "answers";
|
|
6571
|
-
|
|
8470
|
+
corrections: "corrections";
|
|
6572
8471
|
"owner-answers": "owner-answers";
|
|
6573
8472
|
baseline: "baseline";
|
|
6574
8473
|
initiatives: "initiatives";
|
|
@@ -6592,7 +8491,7 @@ export declare const ProposePlanView: z.ZodObject<{
|
|
|
6592
8491
|
* `merge` is Sync's merge of a ready PR; `ai-model` a change of where runtime.yaml sends the
|
|
6593
8492
|
* model's key (its provider, keyEnv or an address); `ai-test` a Test of settings not committed.
|
|
6594
8493
|
*/
|
|
6595
|
-
export declare const CONFIRMED_WRITES: readonly ["handoff", "release-prs", "merge", "task-pr", "digest-send", "propose", "step-run", "ai-model", "ai-test"];
|
|
8494
|
+
export declare const CONFIRMED_WRITES: readonly ["handoff", "release-prs", "merge", "task-pr", "digest-send", "propose", "step-run", "ai-model", "ai-test", "work-items", "owner-ask"];
|
|
6596
8495
|
export declare const ConfirmedWrite: z.ZodEnum<{
|
|
6597
8496
|
propose: "propose";
|
|
6598
8497
|
handoff: "handoff";
|
|
@@ -6603,6 +8502,8 @@ export declare const ConfirmedWrite: z.ZodEnum<{
|
|
|
6603
8502
|
"step-run": "step-run";
|
|
6604
8503
|
"ai-model": "ai-model";
|
|
6605
8504
|
"ai-test": "ai-test";
|
|
8505
|
+
"work-items": "work-items";
|
|
8506
|
+
"owner-ask": "owner-ask";
|
|
6606
8507
|
}>;
|
|
6607
8508
|
/** A confirmation the server gave the page: single use, for one write and target, two minutes. */
|
|
6608
8509
|
export declare const Confirmation: z.ZodString;
|
|
@@ -6617,6 +8518,8 @@ export declare const ConfirmationRequest: z.ZodObject<{
|
|
|
6617
8518
|
"step-run": "step-run";
|
|
6618
8519
|
"ai-model": "ai-model";
|
|
6619
8520
|
"ai-test": "ai-test";
|
|
8521
|
+
"work-items": "work-items";
|
|
8522
|
+
"owner-ask": "owner-ask";
|
|
6620
8523
|
}>;
|
|
6621
8524
|
target: z.ZodString;
|
|
6622
8525
|
pageKey: z.ZodOptional<z.ZodString>;
|
|
@@ -6633,6 +8536,8 @@ export declare const ConfirmationView: z.ZodObject<{
|
|
|
6633
8536
|
"step-run": "step-run";
|
|
6634
8537
|
"ai-model": "ai-model";
|
|
6635
8538
|
"ai-test": "ai-test";
|
|
8539
|
+
"work-items": "work-items";
|
|
8540
|
+
"owner-ask": "owner-ask";
|
|
6636
8541
|
}>;
|
|
6637
8542
|
target: z.ZodString;
|
|
6638
8543
|
expiresAt: z.ZodString;
|
|
@@ -6647,10 +8552,10 @@ export declare const ProposeRequest: z.ZodObject<{
|
|
|
6647
8552
|
scope: z.ZodEnum<{
|
|
6648
8553
|
"service-desk": "service-desk";
|
|
6649
8554
|
"org-pack": "org-pack";
|
|
8555
|
+
work: "work";
|
|
6650
8556
|
audit: "audit";
|
|
6651
|
-
corrections: "corrections";
|
|
6652
8557
|
answers: "answers";
|
|
6653
|
-
|
|
8558
|
+
corrections: "corrections";
|
|
6654
8559
|
"owner-answers": "owner-answers";
|
|
6655
8560
|
baseline: "baseline";
|
|
6656
8561
|
initiatives: "initiatives";
|
|
@@ -7700,6 +9605,19 @@ export declare const ReleasePrsRequest: z.ZodObject<{
|
|
|
7700
9605
|
/** 2.75.0 (seventh UX walk): tick (done) or untick a task in the change's tasks.md. */
|
|
7701
9606
|
export declare const TaskDoneRequest: z.ZodObject<{
|
|
7702
9607
|
done: z.ZodBoolean;
|
|
9608
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
9609
|
+
}, z.core.$strict>;
|
|
9610
|
+
/**
|
|
9611
|
+
* 3.3.0 (app-only audit): Set the upstream of the branch checked out to the same branch on a
|
|
9612
|
+
* remote (`<remote>/<branch>`), when Bring in what merged found it follows none.
|
|
9613
|
+
*/
|
|
9614
|
+
export declare const UpstreamRequest: z.ZodObject<{
|
|
9615
|
+
upstream: z.ZodString;
|
|
9616
|
+
}, z.core.$strict>;
|
|
9617
|
+
/** 3.3.0 (app-only audit): Build and raise PR; `raise` pushes and opens the PR (`task-pr`). */
|
|
9618
|
+
export declare const TaskBuildRequest: z.ZodObject<{
|
|
9619
|
+
raise: z.ZodOptional<z.ZodBoolean>;
|
|
9620
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
7703
9621
|
}, z.core.$strict>;
|
|
7704
9622
|
/**
|
|
7705
9623
|
* 2.83.0 (ninth UX walk): name a change's owners per role from the change page (an empty list
|
|
@@ -7853,7 +9771,10 @@ export declare const SaveNotifyRequest: z.ZodObject<{
|
|
|
7853
9771
|
channel: z.ZodOptional<z.ZodString>;
|
|
7854
9772
|
}, z.core.$strict>;
|
|
7855
9773
|
/** ADR 0048: show the digest, or send it through the notify adapter (the click is the approval). */
|
|
7856
|
-
/**
|
|
9774
|
+
/**
|
|
9775
|
+
* 3.0.0 (ADR 0186): send needs the person's confirmation from the app (`digest-send`). 3.1.0
|
|
9776
|
+
* (review round 50): of the channel it posts to, GET /api/me's notify.to.
|
|
9777
|
+
*/
|
|
7857
9778
|
export declare const SendDigestRequest: z.ZodObject<{
|
|
7858
9779
|
send: z.ZodDefault<z.ZodBoolean>;
|
|
7859
9780
|
confirmation: z.ZodOptional<z.ZodString>;
|
|
@@ -7911,7 +9832,7 @@ export declare const InitiativeSavedView: z.ZodObject<{
|
|
|
7911
9832
|
/** ADR 0078: the questions in questions/, and the files that aren't valid questions. */
|
|
7912
9833
|
export declare const QuestionList: z.ZodObject<{
|
|
7913
9834
|
questions: z.ZodArray<z.ZodObject<{
|
|
7914
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
9835
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
7915
9836
|
id: z.ZodString;
|
|
7916
9837
|
askedBy: z.ZodObject<{
|
|
7917
9838
|
step: z.ZodString;
|
|
@@ -7947,6 +9868,21 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
7947
9868
|
delivery: "delivery";
|
|
7948
9869
|
analysis: "analysis";
|
|
7949
9870
|
}>>;
|
|
9871
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
9872
|
+
business: "business";
|
|
9873
|
+
delivery: "delivery";
|
|
9874
|
+
design: "design";
|
|
9875
|
+
}>>;
|
|
9876
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
9877
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
9878
|
+
product: "product";
|
|
9879
|
+
architecture: "architecture";
|
|
9880
|
+
delivery: "delivery";
|
|
9881
|
+
analysis: "analysis";
|
|
9882
|
+
}>>;
|
|
9883
|
+
by: z.ZodString;
|
|
9884
|
+
at: z.ZodISODateTime;
|
|
9885
|
+
}, z.core.$strict>>;
|
|
7950
9886
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
7951
9887
|
finding: z.ZodOptional<z.ZodObject<{
|
|
7952
9888
|
change: z.ZodString;
|
|
@@ -8107,6 +10043,11 @@ export declare const QuestionList: z.ZodObject<{
|
|
|
8107
10043
|
delivery: "delivery";
|
|
8108
10044
|
analysis: "analysis";
|
|
8109
10045
|
}>>;
|
|
10046
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
10047
|
+
business: "business";
|
|
10048
|
+
delivery: "delivery";
|
|
10049
|
+
design: "design";
|
|
10050
|
+
}>>;
|
|
8110
10051
|
proposal: z.ZodOptional<z.ZodObject<{
|
|
8111
10052
|
answer: z.ZodObject<{
|
|
8112
10053
|
option: z.ZodOptional<z.ZodNumber>;
|
|
@@ -8161,11 +10102,13 @@ export declare const AnswerQuestionRequest: z.ZodObject<{
|
|
|
8161
10102
|
vendor: "vendor";
|
|
8162
10103
|
}>>;
|
|
8163
10104
|
name: z.ZodOptional<z.ZodString>;
|
|
10105
|
+
ignore: z.ZodOptional<z.ZodLiteral<true>>;
|
|
10106
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
8164
10107
|
}, z.core.$strict>;
|
|
8165
10108
|
/** ADR 0078: the answered question, the command to run next and, for a repo type, its skill file. */
|
|
8166
10109
|
export declare const AnsweredQuestion: z.ZodObject<{
|
|
8167
10110
|
question: z.ZodObject<{
|
|
8168
|
-
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
|
|
10111
|
+
schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
|
|
8169
10112
|
id: z.ZodString;
|
|
8170
10113
|
askedBy: z.ZodObject<{
|
|
8171
10114
|
step: z.ZodString;
|
|
@@ -8201,6 +10144,21 @@ export declare const AnsweredQuestion: z.ZodObject<{
|
|
|
8201
10144
|
delivery: "delivery";
|
|
8202
10145
|
analysis: "analysis";
|
|
8203
10146
|
}>>;
|
|
10147
|
+
asks: z.ZodOptional<z.ZodEnum<{
|
|
10148
|
+
business: "business";
|
|
10149
|
+
delivery: "delivery";
|
|
10150
|
+
design: "design";
|
|
10151
|
+
}>>;
|
|
10152
|
+
routed: z.ZodOptional<z.ZodObject<{
|
|
10153
|
+
from: z.ZodOptional<z.ZodEnum<{
|
|
10154
|
+
product: "product";
|
|
10155
|
+
architecture: "architecture";
|
|
10156
|
+
delivery: "delivery";
|
|
10157
|
+
analysis: "analysis";
|
|
10158
|
+
}>>;
|
|
10159
|
+
by: z.ZodString;
|
|
10160
|
+
at: z.ZodISODateTime;
|
|
10161
|
+
}, z.core.$strict>>;
|
|
8204
10162
|
askedOf: z.ZodOptional<z.ZodString>;
|
|
8205
10163
|
finding: z.ZodOptional<z.ZodObject<{
|
|
8206
10164
|
change: z.ZodString;
|
|
@@ -9510,9 +11468,9 @@ export declare const CandidateSuggestion: z.ZodObject<{
|
|
|
9510
11468
|
api: z.ZodString;
|
|
9511
11469
|
score: z.ZodNumber;
|
|
9512
11470
|
why: z.ZodEnum<{
|
|
9513
|
-
"same-path": "same-path";
|
|
9514
11471
|
prefix: "prefix";
|
|
9515
11472
|
parameter: "parameter";
|
|
11473
|
+
"same-path": "same-path";
|
|
9516
11474
|
"names-alike": "names-alike";
|
|
9517
11475
|
setting: "setting";
|
|
9518
11476
|
"operation-words": "operation-words";
|
|
@@ -9539,9 +11497,9 @@ export declare const CandidateCallView: z.ZodObject<{
|
|
|
9539
11497
|
api: z.ZodString;
|
|
9540
11498
|
score: z.ZodNumber;
|
|
9541
11499
|
why: z.ZodEnum<{
|
|
9542
|
-
"same-path": "same-path";
|
|
9543
11500
|
prefix: "prefix";
|
|
9544
11501
|
parameter: "parameter";
|
|
11502
|
+
"same-path": "same-path";
|
|
9545
11503
|
"names-alike": "names-alike";
|
|
9546
11504
|
setting: "setting";
|
|
9547
11505
|
"operation-words": "operation-words";
|
|
@@ -9552,9 +11510,9 @@ export declare const CandidateCallView: z.ZodObject<{
|
|
|
9552
11510
|
api: z.ZodString;
|
|
9553
11511
|
score: z.ZodNumber;
|
|
9554
11512
|
why: z.ZodEnum<{
|
|
9555
|
-
"same-path": "same-path";
|
|
9556
11513
|
prefix: "prefix";
|
|
9557
11514
|
parameter: "parameter";
|
|
11515
|
+
"same-path": "same-path";
|
|
9558
11516
|
"names-alike": "names-alike";
|
|
9559
11517
|
setting: "setting";
|
|
9560
11518
|
"operation-words": "operation-words";
|
|
@@ -9603,9 +11561,9 @@ export declare const LinkCandidatesView: z.ZodObject<{
|
|
|
9603
11561
|
api: z.ZodString;
|
|
9604
11562
|
score: z.ZodNumber;
|
|
9605
11563
|
why: z.ZodEnum<{
|
|
9606
|
-
"same-path": "same-path";
|
|
9607
11564
|
prefix: "prefix";
|
|
9608
11565
|
parameter: "parameter";
|
|
11566
|
+
"same-path": "same-path";
|
|
9609
11567
|
"names-alike": "names-alike";
|
|
9610
11568
|
setting: "setting";
|
|
9611
11569
|
"operation-words": "operation-words";
|
|
@@ -9616,9 +11574,9 @@ export declare const LinkCandidatesView: z.ZodObject<{
|
|
|
9616
11574
|
api: z.ZodString;
|
|
9617
11575
|
score: z.ZodNumber;
|
|
9618
11576
|
why: z.ZodEnum<{
|
|
9619
|
-
"same-path": "same-path";
|
|
9620
11577
|
prefix: "prefix";
|
|
9621
11578
|
parameter: "parameter";
|
|
11579
|
+
"same-path": "same-path";
|
|
9622
11580
|
"names-alike": "names-alike";
|
|
9623
11581
|
setting: "setting";
|
|
9624
11582
|
"operation-words": "operation-words";
|
|
@@ -10121,17 +12079,211 @@ export declare const QuestionsProposeView: z.ZodObject<{
|
|
|
10121
12079
|
prompt: z.ZodOptional<z.ZodString>;
|
|
10122
12080
|
done: z.ZodOptional<z.ZodString>;
|
|
10123
12081
|
}, z.core.$strip>;
|
|
10124
|
-
/** 2.84.0: GET /api/upgrade: the upgrade steps this metarepo waits on (atticus upgrade --check). */
|
|
10125
|
-
export declare const UpgradeView: z.ZodObject<{
|
|
10126
|
-
atticus: z.ZodString;
|
|
10127
|
-
newer: z.ZodBoolean;
|
|
10128
|
-
stamp: z.ZodOptional<z.ZodString>;
|
|
10129
|
-
pending: z.ZodArray<z.ZodObject<{
|
|
12082
|
+
/** 2.84.0: GET /api/upgrade: the upgrade steps this metarepo waits on (atticus upgrade --check). */
|
|
12083
|
+
export declare const UpgradeView: z.ZodObject<{
|
|
12084
|
+
atticus: z.ZodString;
|
|
12085
|
+
newer: z.ZodBoolean;
|
|
12086
|
+
stamp: z.ZodOptional<z.ZodString>;
|
|
12087
|
+
pending: z.ZodArray<z.ZodObject<{
|
|
12088
|
+
id: z.ZodString;
|
|
12089
|
+
summary: z.ZodString;
|
|
12090
|
+
files: z.ZodArray<z.ZodString>;
|
|
12091
|
+
}, z.core.$strip>>;
|
|
12092
|
+
}, z.core.$strip>;
|
|
12093
|
+
/**
|
|
12094
|
+
* 3.5.0: what a setup edit changed, or with `preview: true` would change: the file
|
|
12095
|
+
* (metarepo-relative), its lines (what each was, none when added; what it is now, none when
|
|
12096
|
+
* removed), whether it was written, and what to do next (Propose).
|
|
12097
|
+
*/
|
|
12098
|
+
export declare const FileEditView: z.ZodObject<{
|
|
12099
|
+
path: z.ZodString;
|
|
12100
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
12101
|
+
was: z.ZodOptional<z.ZodString>;
|
|
12102
|
+
now: z.ZodOptional<z.ZodString>;
|
|
12103
|
+
}, z.core.$strip>>;
|
|
12104
|
+
written: z.ZodBoolean;
|
|
12105
|
+
note: z.ZodString;
|
|
12106
|
+
confirm: z.ZodOptional<z.ZodLiteral<"ai-model">>;
|
|
12107
|
+
}, z.core.$strip>;
|
|
12108
|
+
/** GET /api/setup/metarepo: whether this folder is a metarepo, and what Create would use. */
|
|
12109
|
+
export declare const SetupMetarepoView: z.ZodObject<{
|
|
12110
|
+
metarepo: z.ZodBoolean;
|
|
12111
|
+
root: z.ZodString;
|
|
12112
|
+
folder: z.ZodString;
|
|
12113
|
+
suggested: z.ZodObject<{
|
|
12114
|
+
name: z.ZodString;
|
|
12115
|
+
platform: z.ZodString;
|
|
12116
|
+
}, z.core.$strip>;
|
|
12117
|
+
origin: z.ZodOptional<z.ZodString>;
|
|
12118
|
+
metarepoId: z.ZodOptional<z.ZodString>;
|
|
12119
|
+
}, z.core.$strip>;
|
|
12120
|
+
export declare const CreateMetarepoRequest: z.ZodObject<{
|
|
12121
|
+
name: z.ZodString;
|
|
12122
|
+
platform: z.ZodString;
|
|
12123
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
12124
|
+
metarepo: z.ZodOptional<z.ZodString>;
|
|
12125
|
+
}, z.core.$strict>;
|
|
12126
|
+
export declare const OpenFolderRequest: z.ZodObject<{
|
|
12127
|
+
path: z.ZodString;
|
|
12128
|
+
}, z.core.$strict>;
|
|
12129
|
+
export declare const OpenFolderView: z.ZodObject<{
|
|
12130
|
+
url: z.ZodString;
|
|
12131
|
+
root: z.ZodString;
|
|
12132
|
+
metarepo: z.ZodBoolean;
|
|
12133
|
+
}, z.core.$strip>;
|
|
12134
|
+
/** Repos to add: pasted clone URLs (one a line), or a folder of clones (repos discover's code). */
|
|
12135
|
+
export declare const ReposPlanRequest: z.ZodObject<{
|
|
12136
|
+
urls: z.ZodOptional<z.ZodString>;
|
|
12137
|
+
dir: z.ZodOptional<z.ZodString>;
|
|
12138
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
12139
|
+
}, z.core.$strict>;
|
|
12140
|
+
export declare const PlannedRepoView: z.ZodObject<{
|
|
12141
|
+
id: z.ZodString;
|
|
12142
|
+
url: z.ZodString;
|
|
12143
|
+
given: z.ZodOptional<z.ZodString>;
|
|
12144
|
+
type: z.ZodString;
|
|
12145
|
+
defaultBranch: z.ZodOptional<z.ZodString>;
|
|
12146
|
+
renamed: z.ZodOptional<z.ZodObject<{
|
|
12147
|
+
from: z.ZodString;
|
|
12148
|
+
why: z.ZodString;
|
|
12149
|
+
}, z.core.$strip>>;
|
|
12150
|
+
detected: z.ZodOptional<z.ZodObject<{
|
|
12151
|
+
signals: z.ZodArray<z.ZodString>;
|
|
12152
|
+
confidence: z.ZodString;
|
|
12153
|
+
}, z.core.$strip>>;
|
|
12154
|
+
}, z.core.$strip>;
|
|
12155
|
+
export declare const ReposPlanView: z.ZodObject<{
|
|
12156
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
12157
|
+
platforms: z.ZodArray<z.ZodString>;
|
|
12158
|
+
repos: z.ZodArray<z.ZodObject<{
|
|
12159
|
+
id: z.ZodString;
|
|
12160
|
+
url: z.ZodString;
|
|
12161
|
+
given: z.ZodOptional<z.ZodString>;
|
|
12162
|
+
type: z.ZodString;
|
|
12163
|
+
defaultBranch: z.ZodOptional<z.ZodString>;
|
|
12164
|
+
renamed: z.ZodOptional<z.ZodObject<{
|
|
12165
|
+
from: z.ZodString;
|
|
12166
|
+
why: z.ZodString;
|
|
12167
|
+
}, z.core.$strip>>;
|
|
12168
|
+
detected: z.ZodOptional<z.ZodObject<{
|
|
12169
|
+
signals: z.ZodArray<z.ZodString>;
|
|
12170
|
+
confidence: z.ZodString;
|
|
12171
|
+
}, z.core.$strip>>;
|
|
12172
|
+
}, z.core.$strip>>;
|
|
12173
|
+
listed: z.ZodArray<z.ZodObject<{
|
|
12174
|
+
url: z.ZodString;
|
|
12175
|
+
id: z.ZodString;
|
|
12176
|
+
}, z.core.$strip>>;
|
|
12177
|
+
refused: z.ZodArray<z.ZodObject<{
|
|
12178
|
+
given: z.ZodString;
|
|
12179
|
+
why: z.ZodString;
|
|
12180
|
+
}, z.core.$strip>>;
|
|
12181
|
+
skipped: z.ZodArray<z.ZodObject<{
|
|
12182
|
+
path: z.ZodString;
|
|
12183
|
+
reason: z.ZodString;
|
|
12184
|
+
}, z.core.$strip>>;
|
|
12185
|
+
}, z.core.$strip>;
|
|
12186
|
+
export declare const AddReposRequest: z.ZodObject<{
|
|
12187
|
+
platform: z.ZodOptional<z.ZodString>;
|
|
12188
|
+
repos: z.ZodArray<z.ZodObject<{
|
|
10130
12189
|
id: z.ZodString;
|
|
10131
|
-
|
|
10132
|
-
|
|
12190
|
+
url: z.ZodString;
|
|
12191
|
+
type: z.ZodOptional<z.ZodString>;
|
|
12192
|
+
owner: z.ZodOptional<z.ZodString>;
|
|
12193
|
+
defaultBranch: z.ZodOptional<z.ZodString>;
|
|
12194
|
+
description: z.ZodOptional<z.ZodString>;
|
|
12195
|
+
}, z.core.$strict>>;
|
|
12196
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
12197
|
+
}, z.core.$strict>;
|
|
12198
|
+
export declare const RepoTypeDetectView: z.ZodObject<{
|
|
12199
|
+
repo: z.ZodString;
|
|
12200
|
+
from: z.ZodEnum<{
|
|
12201
|
+
files: "files";
|
|
12202
|
+
"repo-types": "repo-types";
|
|
12203
|
+
}>;
|
|
12204
|
+
verdict: z.ZodString;
|
|
12205
|
+
type: z.ZodOptional<z.ZodString>;
|
|
12206
|
+
signals: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
12207
|
+
confidence: z.ZodOptional<z.ZodString>;
|
|
12208
|
+
matches: z.ZodArray<z.ZodObject<{
|
|
12209
|
+
type: z.ZodString;
|
|
12210
|
+
name: z.ZodString;
|
|
12211
|
+
score: z.ZodNumber;
|
|
12212
|
+
}, z.core.$strip>>;
|
|
12213
|
+
}, z.core.$strip>;
|
|
12214
|
+
export declare const RepoTypeRequest: z.ZodObject<{
|
|
12215
|
+
type: z.ZodString;
|
|
12216
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
12217
|
+
}, z.core.$strict>;
|
|
12218
|
+
export declare const AdaptersView: z.ZodObject<{
|
|
12219
|
+
path: z.ZodString;
|
|
12220
|
+
sha256: z.ZodString;
|
|
12221
|
+
kinds: z.ZodArray<z.ZodObject<{
|
|
12222
|
+
kind: z.ZodString;
|
|
12223
|
+
types: z.ZodArray<z.ZodString>;
|
|
12224
|
+
fields: z.ZodArray<z.ZodObject<{
|
|
12225
|
+
name: z.ZodString;
|
|
12226
|
+
list: z.ZodBoolean;
|
|
12227
|
+
}, z.core.$strip>>;
|
|
12228
|
+
current: z.ZodNullable<z.ZodObject<{
|
|
12229
|
+
type: z.ZodString;
|
|
12230
|
+
settings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
|
|
12231
|
+
}, z.core.$strip>>;
|
|
10133
12232
|
}, z.core.$strip>>;
|
|
12233
|
+
problems: z.ZodArray<z.ZodString>;
|
|
12234
|
+
}, z.core.$strip>;
|
|
12235
|
+
export declare const AdapterRequest: z.ZodObject<{
|
|
12236
|
+
value: z.ZodNullable<z.ZodObject<{
|
|
12237
|
+
type: z.ZodString;
|
|
12238
|
+
settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
|
|
12239
|
+
}, z.core.$strict>>;
|
|
12240
|
+
baseSha256: z.ZodOptional<z.ZodString>;
|
|
12241
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
12242
|
+
}, z.core.$strict>;
|
|
12243
|
+
export declare const OrgPackFileView: z.ZodObject<{
|
|
12244
|
+
path: z.ZodString;
|
|
12245
|
+
rel: z.ZodString;
|
|
12246
|
+
content: z.ZodString;
|
|
12247
|
+
sha256: z.ZodString;
|
|
12248
|
+
exists: z.ZodBoolean;
|
|
12249
|
+
checked: z.ZodBoolean;
|
|
10134
12250
|
}, z.core.$strip>;
|
|
12251
|
+
export declare const OrgPackFileRequest: z.ZodObject<{
|
|
12252
|
+
path: z.ZodString;
|
|
12253
|
+
content: z.ZodString;
|
|
12254
|
+
baseSha256: z.ZodString;
|
|
12255
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
12256
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
12257
|
+
}, z.core.$strict>;
|
|
12258
|
+
export declare const PatternRequest: z.ZodObject<{
|
|
12259
|
+
code: z.ZodString;
|
|
12260
|
+
name: z.ZodString;
|
|
12261
|
+
definition: z.ZodString;
|
|
12262
|
+
interaction: z.ZodString;
|
|
12263
|
+
route: z.ZodString;
|
|
12264
|
+
targetType: z.ZodString;
|
|
12265
|
+
controls: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
12266
|
+
source: z.ZodString;
|
|
12267
|
+
version: z.ZodOptional<z.ZodString>;
|
|
12268
|
+
status: z.ZodOptional<z.ZodString>;
|
|
12269
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
12270
|
+
}, z.core.$strict>;
|
|
12271
|
+
export declare const SourceRequest: z.ZodObject<{
|
|
12272
|
+
type: z.ZodString;
|
|
12273
|
+
location: z.ZodString;
|
|
12274
|
+
id: z.ZodOptional<z.ZodString>;
|
|
12275
|
+
path: z.ZodOptional<z.ZodString>;
|
|
12276
|
+
ref: z.ZodOptional<z.ZodString>;
|
|
12277
|
+
preview: z.ZodOptional<z.ZodBoolean>;
|
|
12278
|
+
}, z.core.$strict>;
|
|
12279
|
+
export type FileEditViewT = z.infer<typeof FileEditView>;
|
|
12280
|
+
export type SetupMetarepoViewT = z.infer<typeof SetupMetarepoView>;
|
|
12281
|
+
export type ReposPlanViewT = z.infer<typeof ReposPlanView>;
|
|
12282
|
+
export type PlannedRepoViewT = z.infer<typeof PlannedRepoView>;
|
|
12283
|
+
export type RepoTypeDetectViewT = z.infer<typeof RepoTypeDetectView>;
|
|
12284
|
+
export type AdaptersViewT = z.infer<typeof AdaptersView>;
|
|
12285
|
+
export type OrgPackFileViewT = z.infer<typeof OrgPackFileView>;
|
|
12286
|
+
export type OpenFolderViewT = z.infer<typeof OpenFolderView>;
|
|
10135
12287
|
export declare const ConnectLinksRequest: z.ZodObject<{
|
|
10136
12288
|
from: z.ZodString;
|
|
10137
12289
|
to: z.ZodObject<{
|
|
@@ -10238,6 +12390,7 @@ export declare const SketchStrokeRequest: z.ZodObject<{
|
|
|
10238
12390
|
kind: z.ZodEnum<{
|
|
10239
12391
|
table: "table";
|
|
10240
12392
|
call: "call";
|
|
12393
|
+
retire: "retire";
|
|
10241
12394
|
topic: "topic";
|
|
10242
12395
|
remove: "remove";
|
|
10243
12396
|
retarget: "retarget";
|
|
@@ -10292,8 +12445,8 @@ export declare const SketchResult: z.ZodObject<{
|
|
|
10292
12445
|
system: "system";
|
|
10293
12446
|
component: "component";
|
|
10294
12447
|
table: "table";
|
|
10295
|
-
topic: "topic";
|
|
10296
12448
|
box: "box";
|
|
12449
|
+
topic: "topic";
|
|
10297
12450
|
}>;
|
|
10298
12451
|
boundary: z.ZodOptional<z.ZodEnum<{
|
|
10299
12452
|
product: "product";
|
|
@@ -10556,223 +12709,828 @@ export type UpgradeViewT = z.infer<typeof UpgradeView>;
|
|
|
10556
12709
|
export declare const CopilotRunKind: z.ZodEnum<{
|
|
10557
12710
|
repos: "repos";
|
|
10558
12711
|
stale: "stale";
|
|
10559
|
-
gaps: "gaps";
|
|
10560
12712
|
all: "all";
|
|
12713
|
+
gaps: "gaps";
|
|
10561
12714
|
}>;
|
|
10562
12715
|
export declare const StartCopilotRunRequest: z.ZodObject<{
|
|
10563
12716
|
kind: z.ZodEnum<{
|
|
10564
12717
|
repos: "repos";
|
|
10565
12718
|
stale: "stale";
|
|
12719
|
+
all: "all";
|
|
10566
12720
|
gaps: "gaps";
|
|
12721
|
+
}>;
|
|
12722
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
12723
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
12724
|
+
}, z.core.$strip>;
|
|
12725
|
+
export declare const CopilotRunState: z.ZodEnum<{
|
|
12726
|
+
done: "done";
|
|
12727
|
+
failed: "failed";
|
|
12728
|
+
running: "running";
|
|
12729
|
+
stopped: "stopped";
|
|
12730
|
+
}>;
|
|
12731
|
+
export declare const CopilotRunTab: z.ZodObject<{
|
|
12732
|
+
id: z.ZodString;
|
|
12733
|
+
title: z.ZodString;
|
|
12734
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12735
|
+
state: z.ZodEnum<{
|
|
12736
|
+
failed: "failed";
|
|
12737
|
+
running: "running";
|
|
12738
|
+
ended: "ended";
|
|
12739
|
+
}>;
|
|
12740
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
12741
|
+
from: z.ZodNumber;
|
|
12742
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12743
|
+
}, z.core.$strip>;
|
|
12744
|
+
export declare const CopilotRunView: z.ZodObject<{
|
|
12745
|
+
runId: z.ZodString;
|
|
12746
|
+
jobId: z.ZodString;
|
|
12747
|
+
kind: z.ZodEnum<{
|
|
12748
|
+
repos: "repos";
|
|
12749
|
+
stale: "stale";
|
|
10567
12750
|
all: "all";
|
|
12751
|
+
gaps: "gaps";
|
|
10568
12752
|
}>;
|
|
10569
12753
|
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10570
12754
|
force: z.ZodOptional<z.ZodBoolean>;
|
|
12755
|
+
state: z.ZodEnum<{
|
|
12756
|
+
done: "done";
|
|
12757
|
+
failed: "failed";
|
|
12758
|
+
running: "running";
|
|
12759
|
+
stopped: "stopped";
|
|
12760
|
+
}>;
|
|
12761
|
+
by: z.ZodOptional<z.ZodString>;
|
|
12762
|
+
startedAt: z.ZodString;
|
|
12763
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12764
|
+
model: z.ZodOptional<z.ZodString>;
|
|
12765
|
+
progress: z.ZodObject<{
|
|
12766
|
+
repos: z.ZodNumber;
|
|
12767
|
+
repoIndex: z.ZodNumber;
|
|
12768
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12769
|
+
session: z.ZodOptional<z.ZodString>;
|
|
12770
|
+
sessions: z.ZodNumber;
|
|
12771
|
+
}, z.core.$strip>;
|
|
12772
|
+
totals: z.ZodObject<{
|
|
12773
|
+
kept: z.ZodNumber;
|
|
12774
|
+
rejected: z.ZodNumber;
|
|
12775
|
+
tokens: z.ZodNumber;
|
|
12776
|
+
}, z.core.$strip>;
|
|
12777
|
+
message: z.ZodOptional<z.ZodString>;
|
|
12778
|
+
tabs: z.ZodArray<z.ZodObject<{
|
|
12779
|
+
id: z.ZodString;
|
|
12780
|
+
title: z.ZodString;
|
|
12781
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12782
|
+
state: z.ZodEnum<{
|
|
12783
|
+
failed: "failed";
|
|
12784
|
+
running: "running";
|
|
12785
|
+
ended: "ended";
|
|
12786
|
+
}>;
|
|
12787
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
12788
|
+
from: z.ZodNumber;
|
|
12789
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12790
|
+
}, z.core.$strip>>;
|
|
12791
|
+
}, z.core.$strip>;
|
|
12792
|
+
export declare const CopilotRunCurrent: z.ZodObject<{
|
|
12793
|
+
run: z.ZodNullable<z.ZodObject<{
|
|
12794
|
+
runId: z.ZodString;
|
|
12795
|
+
jobId: z.ZodString;
|
|
12796
|
+
kind: z.ZodEnum<{
|
|
12797
|
+
repos: "repos";
|
|
12798
|
+
stale: "stale";
|
|
12799
|
+
all: "all";
|
|
12800
|
+
gaps: "gaps";
|
|
12801
|
+
}>;
|
|
12802
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
12803
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
12804
|
+
state: z.ZodEnum<{
|
|
12805
|
+
done: "done";
|
|
12806
|
+
failed: "failed";
|
|
12807
|
+
running: "running";
|
|
12808
|
+
stopped: "stopped";
|
|
12809
|
+
}>;
|
|
12810
|
+
by: z.ZodOptional<z.ZodString>;
|
|
12811
|
+
startedAt: z.ZodString;
|
|
12812
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12813
|
+
model: z.ZodOptional<z.ZodString>;
|
|
12814
|
+
progress: z.ZodObject<{
|
|
12815
|
+
repos: z.ZodNumber;
|
|
12816
|
+
repoIndex: z.ZodNumber;
|
|
12817
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12818
|
+
session: z.ZodOptional<z.ZodString>;
|
|
12819
|
+
sessions: z.ZodNumber;
|
|
12820
|
+
}, z.core.$strip>;
|
|
12821
|
+
totals: z.ZodObject<{
|
|
12822
|
+
kept: z.ZodNumber;
|
|
12823
|
+
rejected: z.ZodNumber;
|
|
12824
|
+
tokens: z.ZodNumber;
|
|
12825
|
+
}, z.core.$strip>;
|
|
12826
|
+
message: z.ZodOptional<z.ZodString>;
|
|
12827
|
+
tabs: z.ZodArray<z.ZodObject<{
|
|
12828
|
+
id: z.ZodString;
|
|
12829
|
+
title: z.ZodString;
|
|
12830
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
12831
|
+
state: z.ZodEnum<{
|
|
12832
|
+
failed: "failed";
|
|
12833
|
+
running: "running";
|
|
12834
|
+
ended: "ended";
|
|
12835
|
+
}>;
|
|
12836
|
+
ended: z.ZodOptional<z.ZodString>;
|
|
12837
|
+
from: z.ZodNumber;
|
|
12838
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12839
|
+
}, z.core.$strip>>;
|
|
12840
|
+
}, z.core.$strip>>;
|
|
12841
|
+
allowed: z.ZodBoolean;
|
|
12842
|
+
why: z.ZodOptional<z.ZodString>;
|
|
12843
|
+
model: z.ZodOptional<z.ZodString>;
|
|
12844
|
+
}, z.core.$strip>;
|
|
12845
|
+
export type CopilotRunKindT = z.infer<typeof CopilotRunKind>;
|
|
12846
|
+
export type StartCopilotRunRequestT = z.infer<typeof StartCopilotRunRequest>;
|
|
12847
|
+
export type CopilotRunStateT = z.infer<typeof CopilotRunState>;
|
|
12848
|
+
export type CopilotRunTabT = z.infer<typeof CopilotRunTab>;
|
|
12849
|
+
export type CopilotRunViewT = z.infer<typeof CopilotRunView>;
|
|
12850
|
+
export type CopilotRunCurrentT = z.infer<typeof CopilotRunCurrent>;
|
|
12851
|
+
/** ADR 0187: one thing Atticus is doing or did on this metarepo, for the Console. */
|
|
12852
|
+
export declare const ActivityKind: z.ZodEnum<{
|
|
12853
|
+
local: "local";
|
|
12854
|
+
sync: "sync";
|
|
12855
|
+
index: "index";
|
|
12856
|
+
command: "command";
|
|
12857
|
+
step: "step";
|
|
12858
|
+
copilot: "copilot";
|
|
12859
|
+
scan: "scan";
|
|
12860
|
+
reconcile: "reconcile";
|
|
12861
|
+
intake: "intake";
|
|
12862
|
+
work: "work";
|
|
12863
|
+
handoff: "handoff";
|
|
12864
|
+
}>;
|
|
12865
|
+
export declare const ActivityState: z.ZodEnum<{
|
|
12866
|
+
done: "done";
|
|
12867
|
+
failed: "failed";
|
|
12868
|
+
running: "running";
|
|
12869
|
+
waiting: "waiting";
|
|
12870
|
+
cancelled: "cancelled";
|
|
12871
|
+
ended: "ended";
|
|
12872
|
+
}>;
|
|
12873
|
+
/** Where it was started. */
|
|
12874
|
+
export declare const ActivityWhere: z.ZodEnum<{
|
|
12875
|
+
assistant: "assistant";
|
|
12876
|
+
app: "app";
|
|
12877
|
+
copilot: "copilot";
|
|
12878
|
+
vscode: "vscode";
|
|
12879
|
+
intellij: "intellij";
|
|
12880
|
+
terminal: "terminal";
|
|
12881
|
+
}>;
|
|
12882
|
+
export declare const ActivityEntry: z.ZodObject<{
|
|
12883
|
+
id: z.ZodString;
|
|
12884
|
+
kind: z.ZodEnum<{
|
|
12885
|
+
local: "local";
|
|
12886
|
+
sync: "sync";
|
|
12887
|
+
index: "index";
|
|
12888
|
+
command: "command";
|
|
12889
|
+
step: "step";
|
|
12890
|
+
copilot: "copilot";
|
|
12891
|
+
scan: "scan";
|
|
12892
|
+
reconcile: "reconcile";
|
|
12893
|
+
intake: "intake";
|
|
12894
|
+
work: "work";
|
|
12895
|
+
handoff: "handoff";
|
|
12896
|
+
}>;
|
|
12897
|
+
title: z.ZodOptional<z.ZodString>;
|
|
12898
|
+
where: z.ZodEnum<{
|
|
12899
|
+
assistant: "assistant";
|
|
12900
|
+
app: "app";
|
|
12901
|
+
copilot: "copilot";
|
|
12902
|
+
vscode: "vscode";
|
|
12903
|
+
intellij: "intellij";
|
|
12904
|
+
terminal: "terminal";
|
|
12905
|
+
}>;
|
|
12906
|
+
state: z.ZodEnum<{
|
|
12907
|
+
done: "done";
|
|
12908
|
+
failed: "failed";
|
|
12909
|
+
running: "running";
|
|
12910
|
+
waiting: "waiting";
|
|
12911
|
+
cancelled: "cancelled";
|
|
12912
|
+
ended: "ended";
|
|
12913
|
+
}>;
|
|
12914
|
+
startedAt: z.ZodString;
|
|
12915
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12916
|
+
progress: z.ZodOptional<z.ZodObject<{
|
|
12917
|
+
done: z.ZodNumber;
|
|
12918
|
+
total: z.ZodNumber;
|
|
12919
|
+
message: z.ZodString;
|
|
12920
|
+
}, z.core.$strip>>;
|
|
12921
|
+
exitCode: z.ZodOptional<z.ZodNumber>;
|
|
12922
|
+
lines: z.ZodNumber;
|
|
12923
|
+
from: z.ZodNumber;
|
|
12924
|
+
rev: z.ZodOptional<z.ZodString>;
|
|
12925
|
+
stop: z.ZodOptional<z.ZodString>;
|
|
12926
|
+
jobId: z.ZodOptional<z.ZodString>;
|
|
12927
|
+
copilotRunId: z.ZodOptional<z.ZodString>;
|
|
12928
|
+
runId: z.ZodOptional<z.ZodString>;
|
|
12929
|
+
handoff: z.ZodOptional<z.ZodObject<{
|
|
12930
|
+
runId: z.ZodString;
|
|
12931
|
+
change: z.ZodString;
|
|
12932
|
+
agent: z.ZodOptional<z.ZodString>;
|
|
12933
|
+
promptPath: z.ZodString;
|
|
12934
|
+
output: z.ZodOptional<z.ZodString>;
|
|
12935
|
+
}, z.core.$strip>>;
|
|
12936
|
+
}, z.core.$strip>;
|
|
12937
|
+
export declare const ActivityList: z.ZodObject<{
|
|
12938
|
+
entries: z.ZodArray<z.ZodObject<{
|
|
12939
|
+
id: z.ZodString;
|
|
12940
|
+
kind: z.ZodEnum<{
|
|
12941
|
+
local: "local";
|
|
12942
|
+
sync: "sync";
|
|
12943
|
+
index: "index";
|
|
12944
|
+
command: "command";
|
|
12945
|
+
step: "step";
|
|
12946
|
+
copilot: "copilot";
|
|
12947
|
+
scan: "scan";
|
|
12948
|
+
reconcile: "reconcile";
|
|
12949
|
+
intake: "intake";
|
|
12950
|
+
work: "work";
|
|
12951
|
+
handoff: "handoff";
|
|
12952
|
+
}>;
|
|
12953
|
+
title: z.ZodOptional<z.ZodString>;
|
|
12954
|
+
where: z.ZodEnum<{
|
|
12955
|
+
assistant: "assistant";
|
|
12956
|
+
app: "app";
|
|
12957
|
+
copilot: "copilot";
|
|
12958
|
+
vscode: "vscode";
|
|
12959
|
+
intellij: "intellij";
|
|
12960
|
+
terminal: "terminal";
|
|
12961
|
+
}>;
|
|
12962
|
+
state: z.ZodEnum<{
|
|
12963
|
+
done: "done";
|
|
12964
|
+
failed: "failed";
|
|
12965
|
+
running: "running";
|
|
12966
|
+
waiting: "waiting";
|
|
12967
|
+
cancelled: "cancelled";
|
|
12968
|
+
ended: "ended";
|
|
12969
|
+
}>;
|
|
12970
|
+
startedAt: z.ZodString;
|
|
12971
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
12972
|
+
progress: z.ZodOptional<z.ZodObject<{
|
|
12973
|
+
done: z.ZodNumber;
|
|
12974
|
+
total: z.ZodNumber;
|
|
12975
|
+
message: z.ZodString;
|
|
12976
|
+
}, z.core.$strip>>;
|
|
12977
|
+
exitCode: z.ZodOptional<z.ZodNumber>;
|
|
12978
|
+
lines: z.ZodNumber;
|
|
12979
|
+
from: z.ZodNumber;
|
|
12980
|
+
rev: z.ZodOptional<z.ZodString>;
|
|
12981
|
+
stop: z.ZodOptional<z.ZodString>;
|
|
12982
|
+
jobId: z.ZodOptional<z.ZodString>;
|
|
12983
|
+
copilotRunId: z.ZodOptional<z.ZodString>;
|
|
12984
|
+
runId: z.ZodOptional<z.ZodString>;
|
|
12985
|
+
handoff: z.ZodOptional<z.ZodObject<{
|
|
12986
|
+
runId: z.ZodString;
|
|
12987
|
+
change: z.ZodString;
|
|
12988
|
+
agent: z.ZodOptional<z.ZodString>;
|
|
12989
|
+
promptPath: z.ZodString;
|
|
12990
|
+
output: z.ZodOptional<z.ZodString>;
|
|
12991
|
+
}, z.core.$strip>>;
|
|
12992
|
+
}, z.core.$strip>>;
|
|
12993
|
+
running: z.ZodNumber;
|
|
10571
12994
|
}, z.core.$strip>;
|
|
10572
|
-
export declare const
|
|
10573
|
-
done: "done";
|
|
10574
|
-
failed: "failed";
|
|
10575
|
-
running: "running";
|
|
10576
|
-
stopped: "stopped";
|
|
10577
|
-
}>;
|
|
10578
|
-
export declare const CopilotRunTab: z.ZodObject<{
|
|
12995
|
+
export declare const ActivityLines: z.ZodObject<{
|
|
10579
12996
|
id: z.ZodString;
|
|
10580
|
-
|
|
10581
|
-
|
|
12997
|
+
from: z.ZodNumber;
|
|
12998
|
+
lines: z.ZodArray<z.ZodString>;
|
|
12999
|
+
total: z.ZodNumber;
|
|
10582
13000
|
state: z.ZodEnum<{
|
|
13001
|
+
done: "done";
|
|
10583
13002
|
failed: "failed";
|
|
10584
13003
|
running: "running";
|
|
13004
|
+
waiting: "waiting";
|
|
13005
|
+
cancelled: "cancelled";
|
|
10585
13006
|
ended: "ended";
|
|
10586
13007
|
}>;
|
|
10587
|
-
ended: z.ZodOptional<z.ZodString>;
|
|
10588
|
-
from: z.ZodNumber;
|
|
10589
|
-
lines: z.ZodArray<z.ZodString>;
|
|
10590
13008
|
}, z.core.$strip>;
|
|
10591
|
-
export
|
|
10592
|
-
|
|
13009
|
+
export type ActivityKindT = z.infer<typeof ActivityKind>;
|
|
13010
|
+
export type ActivityStateT = z.infer<typeof ActivityState>;
|
|
13011
|
+
export type ActivityWhereT = z.infer<typeof ActivityWhere>;
|
|
13012
|
+
export type ActivityEntryT = z.infer<typeof ActivityEntry>;
|
|
13013
|
+
export type ActivityListT = z.infer<typeof ActivityList>;
|
|
13014
|
+
export type ActivityLinesT = z.infer<typeof ActivityLines>;
|
|
13015
|
+
/** Messages on the WebSocket at /api/events. */
|
|
13016
|
+
export declare const LiveEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
13017
|
+
type: z.ZodLiteral<"file.changed">;
|
|
13018
|
+
path: z.ZodString;
|
|
13019
|
+
catalog: z.ZodOptional<z.ZodBoolean>;
|
|
13020
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13021
|
+
type: z.ZodLiteral<"job.progress">;
|
|
13022
|
+
jobId: z.ZodString;
|
|
13023
|
+
done: z.ZodNumber;
|
|
13024
|
+
total: z.ZodNumber;
|
|
13025
|
+
message: z.ZodString;
|
|
13026
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13027
|
+
type: z.ZodLiteral<"job.done">;
|
|
10593
13028
|
jobId: z.ZodString;
|
|
10594
|
-
kind: z.ZodEnum<{
|
|
10595
|
-
repos: "repos";
|
|
10596
|
-
stale: "stale";
|
|
10597
|
-
gaps: "gaps";
|
|
10598
|
-
all: "all";
|
|
10599
|
-
}>;
|
|
10600
|
-
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
10601
|
-
force: z.ZodOptional<z.ZodBoolean>;
|
|
10602
13029
|
state: z.ZodEnum<{
|
|
10603
13030
|
done: "done";
|
|
10604
13031
|
failed: "failed";
|
|
10605
13032
|
running: "running";
|
|
10606
|
-
|
|
13033
|
+
cancelled: "cancelled";
|
|
13034
|
+
queued: "queued";
|
|
10607
13035
|
}>;
|
|
10608
|
-
|
|
10609
|
-
|
|
10610
|
-
|
|
10611
|
-
|
|
10612
|
-
|
|
10613
|
-
|
|
10614
|
-
|
|
10615
|
-
|
|
10616
|
-
|
|
10617
|
-
|
|
10618
|
-
|
|
10619
|
-
|
|
10620
|
-
|
|
10621
|
-
|
|
10622
|
-
|
|
13036
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13037
|
+
type: z.ZodLiteral<"index.rebuilt">;
|
|
13038
|
+
records: z.ZodNumber;
|
|
13039
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13040
|
+
type: z.ZodLiteral<"run.changed">;
|
|
13041
|
+
runId: z.ZodString;
|
|
13042
|
+
state: z.ZodEnum<{
|
|
13043
|
+
failed: "failed";
|
|
13044
|
+
prepared: "prepared";
|
|
13045
|
+
waiting: "waiting";
|
|
13046
|
+
produced: "produced";
|
|
13047
|
+
validated: "validated";
|
|
13048
|
+
cancelled: "cancelled";
|
|
13049
|
+
}>;
|
|
13050
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13051
|
+
type: z.ZodLiteral<"copilot-run.state">;
|
|
13052
|
+
run: z.ZodObject<{
|
|
13053
|
+
message: z.ZodOptional<z.ZodString>;
|
|
13054
|
+
by: z.ZodOptional<z.ZodString>;
|
|
13055
|
+
repos: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
13056
|
+
kind: z.ZodEnum<{
|
|
13057
|
+
repos: "repos";
|
|
13058
|
+
stale: "stale";
|
|
13059
|
+
all: "all";
|
|
13060
|
+
gaps: "gaps";
|
|
13061
|
+
}>;
|
|
13062
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
13063
|
+
startedAt: z.ZodString;
|
|
13064
|
+
state: z.ZodEnum<{
|
|
13065
|
+
done: "done";
|
|
13066
|
+
failed: "failed";
|
|
13067
|
+
running: "running";
|
|
13068
|
+
stopped: "stopped";
|
|
13069
|
+
}>;
|
|
13070
|
+
runId: z.ZodString;
|
|
13071
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
13072
|
+
progress: z.ZodObject<{
|
|
13073
|
+
repos: z.ZodNumber;
|
|
13074
|
+
repoIndex: z.ZodNumber;
|
|
13075
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
13076
|
+
session: z.ZodOptional<z.ZodString>;
|
|
13077
|
+
sessions: z.ZodNumber;
|
|
13078
|
+
}, z.core.$strip>;
|
|
13079
|
+
model: z.ZodOptional<z.ZodString>;
|
|
13080
|
+
jobId: z.ZodString;
|
|
13081
|
+
totals: z.ZodObject<{
|
|
13082
|
+
kept: z.ZodNumber;
|
|
13083
|
+
rejected: z.ZodNumber;
|
|
13084
|
+
tokens: z.ZodNumber;
|
|
13085
|
+
}, z.core.$strip>;
|
|
10623
13086
|
}, z.core.$strip>;
|
|
10624
|
-
|
|
10625
|
-
|
|
13087
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13088
|
+
type: z.ZodLiteral<"copilot-run.lines">;
|
|
13089
|
+
runId: z.ZodString;
|
|
13090
|
+
tab: z.ZodString;
|
|
13091
|
+
title: z.ZodString;
|
|
13092
|
+
at: z.ZodNumber;
|
|
13093
|
+
lines: z.ZodArray<z.ZodString>;
|
|
13094
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13095
|
+
type: z.ZodLiteral<"activity.changed">;
|
|
13096
|
+
entry: z.ZodObject<{
|
|
10626
13097
|
id: z.ZodString;
|
|
13098
|
+
kind: z.ZodEnum<{
|
|
13099
|
+
local: "local";
|
|
13100
|
+
sync: "sync";
|
|
13101
|
+
index: "index";
|
|
13102
|
+
command: "command";
|
|
13103
|
+
step: "step";
|
|
13104
|
+
copilot: "copilot";
|
|
13105
|
+
scan: "scan";
|
|
13106
|
+
reconcile: "reconcile";
|
|
13107
|
+
intake: "intake";
|
|
13108
|
+
work: "work";
|
|
13109
|
+
handoff: "handoff";
|
|
13110
|
+
}>;
|
|
13111
|
+
title: z.ZodOptional<z.ZodString>;
|
|
13112
|
+
where: z.ZodEnum<{
|
|
13113
|
+
assistant: "assistant";
|
|
13114
|
+
app: "app";
|
|
13115
|
+
copilot: "copilot";
|
|
13116
|
+
vscode: "vscode";
|
|
13117
|
+
intellij: "intellij";
|
|
13118
|
+
terminal: "terminal";
|
|
13119
|
+
}>;
|
|
13120
|
+
state: z.ZodEnum<{
|
|
13121
|
+
done: "done";
|
|
13122
|
+
failed: "failed";
|
|
13123
|
+
running: "running";
|
|
13124
|
+
waiting: "waiting";
|
|
13125
|
+
cancelled: "cancelled";
|
|
13126
|
+
ended: "ended";
|
|
13127
|
+
}>;
|
|
13128
|
+
startedAt: z.ZodString;
|
|
13129
|
+
finishedAt: z.ZodOptional<z.ZodString>;
|
|
13130
|
+
progress: z.ZodOptional<z.ZodObject<{
|
|
13131
|
+
done: z.ZodNumber;
|
|
13132
|
+
total: z.ZodNumber;
|
|
13133
|
+
message: z.ZodString;
|
|
13134
|
+
}, z.core.$strip>>;
|
|
13135
|
+
exitCode: z.ZodOptional<z.ZodNumber>;
|
|
13136
|
+
lines: z.ZodNumber;
|
|
13137
|
+
from: z.ZodNumber;
|
|
13138
|
+
rev: z.ZodOptional<z.ZodString>;
|
|
13139
|
+
stop: z.ZodOptional<z.ZodString>;
|
|
13140
|
+
jobId: z.ZodOptional<z.ZodString>;
|
|
13141
|
+
copilotRunId: z.ZodOptional<z.ZodString>;
|
|
13142
|
+
runId: z.ZodOptional<z.ZodString>;
|
|
13143
|
+
handoff: z.ZodOptional<z.ZodObject<{
|
|
13144
|
+
runId: z.ZodString;
|
|
13145
|
+
change: z.ZodString;
|
|
13146
|
+
agent: z.ZodOptional<z.ZodString>;
|
|
13147
|
+
promptPath: z.ZodString;
|
|
13148
|
+
output: z.ZodOptional<z.ZodString>;
|
|
13149
|
+
}, z.core.$strip>>;
|
|
13150
|
+
}, z.core.$strip>;
|
|
13151
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13152
|
+
type: z.ZodLiteral<"activity.lines">;
|
|
13153
|
+
id: z.ZodString;
|
|
13154
|
+
at: z.ZodNumber;
|
|
13155
|
+
lines: z.ZodArray<z.ZodString>;
|
|
13156
|
+
}, z.core.$strip>], "type">;
|
|
13157
|
+
/** 3.6.0 (ADR 0191): a person moves a question to another role. */
|
|
13158
|
+
export declare const RouteQuestionRequest: z.ZodObject<{
|
|
13159
|
+
role: z.ZodEnum<{
|
|
13160
|
+
product: "product";
|
|
13161
|
+
architecture: "architecture";
|
|
13162
|
+
delivery: "delivery";
|
|
13163
|
+
analysis: "analysis";
|
|
13164
|
+
}>;
|
|
13165
|
+
}, z.core.$strict>;
|
|
13166
|
+
/**
|
|
13167
|
+
* 3.6.0 (ADR 0191): the owners roles.yaml suggests for a change's roles: the team that owns its
|
|
13168
|
+
* repos (a team's `roles`), else the organisation's default for the role. Suggestions only: a
|
|
13169
|
+
* person accepts one with a click (PUT .../owners), nothing is written by itself. A role the
|
|
13170
|
+
* change already names is left out.
|
|
13171
|
+
*/
|
|
13172
|
+
export declare const OwnerSuggestion: z.ZodObject<{
|
|
13173
|
+
role: z.ZodString;
|
|
13174
|
+
people: z.ZodArray<z.ZodString>;
|
|
13175
|
+
from: z.ZodUnion<readonly [z.ZodObject<{
|
|
13176
|
+
team: z.ZodString;
|
|
13177
|
+
name: z.ZodOptional<z.ZodString>;
|
|
13178
|
+
repos: z.ZodArray<z.ZodString>;
|
|
13179
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13180
|
+
default: z.ZodLiteral<true>;
|
|
13181
|
+
}, z.core.$strip>]>;
|
|
13182
|
+
}, z.core.$strip>;
|
|
13183
|
+
export declare const OwnerSuggestionList: z.ZodObject<{
|
|
13184
|
+
change: z.ZodString;
|
|
13185
|
+
suggestions: z.ZodArray<z.ZodObject<{
|
|
13186
|
+
role: z.ZodString;
|
|
13187
|
+
people: z.ZodArray<z.ZodString>;
|
|
13188
|
+
from: z.ZodUnion<readonly [z.ZodObject<{
|
|
13189
|
+
team: z.ZodString;
|
|
13190
|
+
name: z.ZodOptional<z.ZodString>;
|
|
13191
|
+
repos: z.ZodArray<z.ZodString>;
|
|
13192
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
13193
|
+
default: z.ZodLiteral<true>;
|
|
13194
|
+
}, z.core.$strip>]>;
|
|
13195
|
+
}, z.core.$strip>>;
|
|
13196
|
+
note: z.ZodOptional<z.ZodString>;
|
|
13197
|
+
}, z.core.$strip>;
|
|
13198
|
+
export type OwnerSuggestionListT = z.infer<typeof OwnerSuggestionList>;
|
|
13199
|
+
/** 3.6.0 (ADR 0191): who a change waits on now, by role, with their names. */
|
|
13200
|
+
export declare const WaitsOn: z.ZodObject<{
|
|
13201
|
+
role: z.ZodString;
|
|
13202
|
+
people: z.ZodArray<z.ZodString>;
|
|
13203
|
+
because: z.ZodEnum<{
|
|
13204
|
+
phase: "phase";
|
|
13205
|
+
handoff: "handoff";
|
|
13206
|
+
}>;
|
|
13207
|
+
phase: z.ZodString;
|
|
13208
|
+
}, z.core.$strip>;
|
|
13209
|
+
export type WaitsOnT = z.infer<typeof WaitsOn>;
|
|
13210
|
+
/** 3.6.0 (ADR 0191): a critic finding with the level of what it asks (business, design, delivery). */
|
|
13211
|
+
export declare const FindingView: z.ZodObject<{
|
|
13212
|
+
asks: z.ZodEnum<{
|
|
13213
|
+
business: "business";
|
|
13214
|
+
delivery: "delivery";
|
|
13215
|
+
design: "design";
|
|
13216
|
+
}>;
|
|
13217
|
+
schemaVersion: z.ZodLiteral<1>;
|
|
13218
|
+
id: z.ZodString;
|
|
13219
|
+
kind: z.ZodEnum<{
|
|
13220
|
+
issue: "issue";
|
|
13221
|
+
"knowledge-gap": "knowledge-gap";
|
|
13222
|
+
}>;
|
|
13223
|
+
change: z.ZodString;
|
|
13224
|
+
gate: z.ZodString;
|
|
13225
|
+
round: z.ZodNumber;
|
|
13226
|
+
rule: z.ZodString;
|
|
13227
|
+
layer: z.ZodEnum<{
|
|
13228
|
+
team: "team";
|
|
13229
|
+
constitution: "constitution";
|
|
13230
|
+
org: "org";
|
|
13231
|
+
}>;
|
|
13232
|
+
lens: z.ZodEnum<{
|
|
13233
|
+
release: "release";
|
|
13234
|
+
true: "true";
|
|
13235
|
+
complete: "complete";
|
|
13236
|
+
safe: "safe";
|
|
13237
|
+
ship: "ship";
|
|
13238
|
+
business: "business";
|
|
13239
|
+
architecture: "architecture";
|
|
13240
|
+
story: "story";
|
|
13241
|
+
ux: "ux";
|
|
13242
|
+
delivery: "delivery";
|
|
13243
|
+
"code-and-test": "code-and-test";
|
|
13244
|
+
}>;
|
|
13245
|
+
severity: z.ZodEnum<{
|
|
13246
|
+
blocking: "blocking";
|
|
13247
|
+
gap: "gap";
|
|
13248
|
+
risk: "risk";
|
|
13249
|
+
idea: "idea";
|
|
13250
|
+
}>;
|
|
13251
|
+
artifact: z.ZodString;
|
|
13252
|
+
locator: z.ZodObject<{
|
|
13253
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
13254
|
+
heading: z.ZodOptional<z.ZodString>;
|
|
13255
|
+
record: z.ZodOptional<z.ZodString>;
|
|
13256
|
+
field: z.ZodOptional<z.ZodString>;
|
|
13257
|
+
}, z.core.$strict>;
|
|
13258
|
+
summary: z.ZodString;
|
|
13259
|
+
why: z.ZodString;
|
|
13260
|
+
fix: z.ZodObject<{
|
|
13261
|
+
text: z.ZodString;
|
|
13262
|
+
patch: z.ZodOptional<z.ZodString>;
|
|
13263
|
+
}, z.core.$strict>;
|
|
13264
|
+
evidence: z.ZodArray<z.ZodObject<{
|
|
13265
|
+
source: z.ZodUnion<readonly [z.ZodEnum<{
|
|
13266
|
+
code: "code";
|
|
13267
|
+
config: "config";
|
|
13268
|
+
spec: "spec";
|
|
13269
|
+
gateway: "gateway";
|
|
13270
|
+
"event-config": "event-config";
|
|
13271
|
+
infrastructure: "infrastructure";
|
|
13272
|
+
pipeline: "pipeline";
|
|
13273
|
+
migration: "migration";
|
|
13274
|
+
diagram: "diagram";
|
|
13275
|
+
document: "document";
|
|
13276
|
+
export: "export";
|
|
13277
|
+
manual: "manual";
|
|
13278
|
+
}>, z.ZodEnum<{
|
|
13279
|
+
artifact: "artifact";
|
|
13280
|
+
catalog: "catalog";
|
|
13281
|
+
rule: "rule";
|
|
13282
|
+
}>]>;
|
|
13283
|
+
record: z.ZodOptional<z.ZodString>;
|
|
13284
|
+
path: z.ZodOptional<z.ZodString>;
|
|
13285
|
+
repo: z.ZodOptional<z.ZodString>;
|
|
13286
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
13287
|
+
quote: z.ZodOptional<z.ZodString>;
|
|
13288
|
+
}, z.core.$strict>>;
|
|
13289
|
+
question: z.ZodOptional<z.ZodObject<{
|
|
13290
|
+
text: z.ZodString;
|
|
13291
|
+
owner: z.ZodString;
|
|
13292
|
+
}, z.core.$strict>>;
|
|
13293
|
+
answered: z.ZodOptional<z.ZodObject<{
|
|
13294
|
+
question: z.ZodString;
|
|
13295
|
+
quote: z.ZodString;
|
|
13296
|
+
}, z.core.$strict>>;
|
|
13297
|
+
waivable: z.ZodBoolean;
|
|
13298
|
+
state: z.ZodDefault<z.ZodEnum<{
|
|
13299
|
+
open: "open";
|
|
13300
|
+
applied: "applied";
|
|
13301
|
+
dismissed: "dismissed";
|
|
13302
|
+
waived: "waived";
|
|
13303
|
+
asked: "asked";
|
|
13304
|
+
}>>;
|
|
13305
|
+
resolution: z.ZodOptional<z.ZodObject<{
|
|
13306
|
+
action: z.ZodEnum<{
|
|
13307
|
+
apply: "apply";
|
|
13308
|
+
"edit-and-apply": "edit-and-apply";
|
|
13309
|
+
"not-relevant": "not-relevant";
|
|
13310
|
+
waive: "waive";
|
|
13311
|
+
ask: "ask";
|
|
13312
|
+
}>;
|
|
13313
|
+
by: z.ZodString;
|
|
13314
|
+
at: z.ZodISODateTime;
|
|
13315
|
+
reason: z.ZodOptional<z.ZodString>;
|
|
13316
|
+
askedOf: z.ZodOptional<z.ZodString>;
|
|
13317
|
+
}, z.core.$strict>>;
|
|
13318
|
+
createdAt: z.ZodISODateTime;
|
|
13319
|
+
}, z.core.$strict>;
|
|
13320
|
+
/**
|
|
13321
|
+
* 3.6.0 (ADR 0191): the work items a change's plan puts in the work tracker, one per feature,
|
|
13322
|
+
* story and task, as sync.yaml remembers them. With a manual tracker each is a step for a person
|
|
13323
|
+
* (the fields to copy, and where to record the tracker's id); with a live one, a write the
|
|
13324
|
+
* person confirms (`work-items`).
|
|
13325
|
+
*/
|
|
13326
|
+
export declare const WorkItemPlan: z.ZodObject<{
|
|
13327
|
+
change: z.ZodString;
|
|
13328
|
+
tracker: z.ZodEnum<{
|
|
13329
|
+
manual: "manual";
|
|
13330
|
+
none: "none";
|
|
13331
|
+
live: "live";
|
|
13332
|
+
}>;
|
|
13333
|
+
items: z.ZodArray<z.ZodObject<{
|
|
13334
|
+
key: z.ZodString;
|
|
13335
|
+
type: z.ZodString;
|
|
10627
13336
|
title: z.ZodString;
|
|
10628
|
-
|
|
10629
|
-
|
|
10630
|
-
|
|
10631
|
-
|
|
10632
|
-
|
|
13337
|
+
action: z.ZodEnum<{
|
|
13338
|
+
update: "update";
|
|
13339
|
+
create: "create";
|
|
13340
|
+
unchanged: "unchanged";
|
|
13341
|
+
orphaned: "orphaned";
|
|
10633
13342
|
}>;
|
|
10634
|
-
|
|
10635
|
-
|
|
10636
|
-
|
|
13343
|
+
id: z.ZodOptional<z.ZodString>;
|
|
13344
|
+
step: z.ZodOptional<z.ZodString>;
|
|
13345
|
+
story: z.ZodOptional<z.ZodString>;
|
|
10637
13346
|
}, z.core.$strip>>;
|
|
13347
|
+
command: z.ZodString;
|
|
10638
13348
|
}, z.core.$strip>;
|
|
10639
|
-
export
|
|
10640
|
-
|
|
10641
|
-
|
|
10642
|
-
|
|
10643
|
-
|
|
10644
|
-
|
|
10645
|
-
|
|
10646
|
-
|
|
10647
|
-
|
|
10648
|
-
|
|
10649
|
-
|
|
10650
|
-
|
|
10651
|
-
state: z.ZodEnum<{
|
|
10652
|
-
done: "done";
|
|
10653
|
-
failed: "failed";
|
|
10654
|
-
running: "running";
|
|
10655
|
-
stopped: "stopped";
|
|
13349
|
+
export type WorkItemPlanT = z.infer<typeof WorkItemPlan>;
|
|
13350
|
+
export declare const WorkItemSyncRequest: z.ZodObject<{
|
|
13351
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
13352
|
+
job: z.ZodOptional<z.ZodBoolean>;
|
|
13353
|
+
}, z.core.$strict>;
|
|
13354
|
+
export declare const WorkItemSyncResult: z.ZodObject<{
|
|
13355
|
+
plan: z.ZodObject<{
|
|
13356
|
+
change: z.ZodString;
|
|
13357
|
+
tracker: z.ZodEnum<{
|
|
13358
|
+
manual: "manual";
|
|
13359
|
+
none: "none";
|
|
13360
|
+
live: "live";
|
|
10656
13361
|
}>;
|
|
10657
|
-
|
|
10658
|
-
|
|
10659
|
-
|
|
10660
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10661
|
-
progress: z.ZodObject<{
|
|
10662
|
-
repos: z.ZodNumber;
|
|
10663
|
-
repoIndex: z.ZodNumber;
|
|
10664
|
-
repo: z.ZodOptional<z.ZodString>;
|
|
10665
|
-
session: z.ZodOptional<z.ZodString>;
|
|
10666
|
-
sessions: z.ZodNumber;
|
|
10667
|
-
}, z.core.$strip>;
|
|
10668
|
-
totals: z.ZodObject<{
|
|
10669
|
-
kept: z.ZodNumber;
|
|
10670
|
-
rejected: z.ZodNumber;
|
|
10671
|
-
tokens: z.ZodNumber;
|
|
10672
|
-
}, z.core.$strip>;
|
|
10673
|
-
message: z.ZodOptional<z.ZodString>;
|
|
10674
|
-
tabs: z.ZodArray<z.ZodObject<{
|
|
10675
|
-
id: z.ZodString;
|
|
13362
|
+
items: z.ZodArray<z.ZodObject<{
|
|
13363
|
+
key: z.ZodString;
|
|
13364
|
+
type: z.ZodString;
|
|
10676
13365
|
title: z.ZodString;
|
|
10677
|
-
|
|
10678
|
-
|
|
10679
|
-
|
|
10680
|
-
|
|
10681
|
-
|
|
13366
|
+
action: z.ZodEnum<{
|
|
13367
|
+
update: "update";
|
|
13368
|
+
create: "create";
|
|
13369
|
+
unchanged: "unchanged";
|
|
13370
|
+
orphaned: "orphaned";
|
|
10682
13371
|
}>;
|
|
10683
|
-
|
|
10684
|
-
|
|
10685
|
-
|
|
13372
|
+
id: z.ZodOptional<z.ZodString>;
|
|
13373
|
+
step: z.ZodOptional<z.ZodString>;
|
|
13374
|
+
story: z.ZodOptional<z.ZodString>;
|
|
10686
13375
|
}, z.core.$strip>>;
|
|
13376
|
+
command: z.ZodString;
|
|
13377
|
+
}, z.core.$strip>;
|
|
13378
|
+
lines: z.ZodArray<z.ZodString>;
|
|
13379
|
+
done: z.ZodArray<z.ZodObject<{
|
|
13380
|
+
key: z.ZodString;
|
|
13381
|
+
action: z.ZodString;
|
|
13382
|
+
id: z.ZodString;
|
|
10687
13383
|
}, z.core.$strip>>;
|
|
10688
|
-
|
|
13384
|
+
failed: z.ZodArray<z.ZodObject<{
|
|
13385
|
+
key: z.ZodString;
|
|
13386
|
+
reason: z.ZodString;
|
|
13387
|
+
}, z.core.$strip>>;
|
|
13388
|
+
}, z.core.$strip>;
|
|
13389
|
+
export type WorkItemSyncResultT = z.infer<typeof WorkItemSyncResult>;
|
|
13390
|
+
/**
|
|
13391
|
+
* 3.6.0 (ADR 0191): send an owner question through the configured notifications adapter, on the
|
|
13392
|
+
* person's confirmation (`owner-ask`, target the question's id). With manual notifications it is
|
|
13393
|
+
* a step for a person, as before.
|
|
13394
|
+
*/
|
|
13395
|
+
export declare const SendOwnerAskRequest: z.ZodObject<{
|
|
13396
|
+
confirmation: z.ZodOptional<z.ZodString>;
|
|
13397
|
+
}, z.core.$strict>;
|
|
13398
|
+
export declare const SentOwnerAsk: z.ZodObject<{
|
|
13399
|
+
state: z.ZodEnum<{
|
|
13400
|
+
sent: "sent";
|
|
13401
|
+
step: "step";
|
|
13402
|
+
"not-sent": "not-sent";
|
|
13403
|
+
}>;
|
|
13404
|
+
to: z.ZodString;
|
|
13405
|
+
id: z.ZodOptional<z.ZodString>;
|
|
10689
13406
|
why: z.ZodOptional<z.ZodString>;
|
|
10690
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10691
13407
|
}, z.core.$strip>;
|
|
10692
|
-
export type
|
|
10693
|
-
|
|
10694
|
-
export
|
|
10695
|
-
|
|
10696
|
-
|
|
10697
|
-
export type CopilotRunCurrentT = z.infer<typeof CopilotRunCurrent>;
|
|
10698
|
-
/** Messages on the WebSocket at /api/events. */
|
|
10699
|
-
export declare const LiveEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
10700
|
-
type: z.ZodLiteral<"file.changed">;
|
|
13408
|
+
export type SentOwnerAskT = z.infer<typeof SentOwnerAsk>;
|
|
13409
|
+
/** 3.6.0 (ADR 0191): a passage of the org's wikis or inputs/ files, with where it is. */
|
|
13410
|
+
export declare const KnowledgePassageView: z.ZodObject<{
|
|
13411
|
+
source: z.ZodString;
|
|
13412
|
+
page: z.ZodString;
|
|
10701
13413
|
path: z.ZodString;
|
|
10702
|
-
|
|
10703
|
-
|
|
10704
|
-
|
|
10705
|
-
|
|
10706
|
-
|
|
10707
|
-
|
|
10708
|
-
|
|
10709
|
-
|
|
10710
|
-
|
|
10711
|
-
|
|
10712
|
-
|
|
10713
|
-
|
|
10714
|
-
|
|
10715
|
-
|
|
10716
|
-
|
|
13414
|
+
heading: z.ZodString;
|
|
13415
|
+
line: z.ZodNumber;
|
|
13416
|
+
text: z.ZodString;
|
|
13417
|
+
}, z.core.$strip>;
|
|
13418
|
+
export type KnowledgePassageViewT = z.infer<typeof KnowledgePassageView>;
|
|
13419
|
+
/**
|
|
13420
|
+
* 3.6.0 (ADR 0191): what the organisation's knowledge says to a question, found by its words (no
|
|
13421
|
+
* AI): the knowledge items it matches, each with the quote it rests on, and the passages of the
|
|
13422
|
+
* wikis' snapshots and inputs/ files. Nothing is made up: each shows where it is from.
|
|
13423
|
+
*/
|
|
13424
|
+
export declare const KnowledgeAnswerView: z.ZodObject<{
|
|
13425
|
+
items: z.ZodArray<z.ZodObject<{
|
|
13426
|
+
id: z.ZodString;
|
|
13427
|
+
kind: z.ZodString;
|
|
13428
|
+
title: z.ZodString;
|
|
13429
|
+
quote: z.ZodOptional<z.ZodObject<{
|
|
13430
|
+
source: z.ZodString;
|
|
13431
|
+
page: z.ZodString;
|
|
13432
|
+
section: z.ZodOptional<z.ZodString>;
|
|
13433
|
+
text: z.ZodString;
|
|
13434
|
+
}, z.core.$strip>>;
|
|
13435
|
+
}, z.core.$strip>>;
|
|
13436
|
+
passages: z.ZodArray<z.ZodObject<{
|
|
13437
|
+
source: z.ZodString;
|
|
13438
|
+
page: z.ZodString;
|
|
13439
|
+
path: z.ZodString;
|
|
13440
|
+
heading: z.ZodString;
|
|
13441
|
+
line: z.ZodNumber;
|
|
13442
|
+
text: z.ZodString;
|
|
13443
|
+
}, z.core.$strip>>;
|
|
13444
|
+
command: z.ZodString;
|
|
13445
|
+
}, z.core.$strip>;
|
|
13446
|
+
export type KnowledgeAnswerViewT = z.infer<typeof KnowledgeAnswerView>;
|
|
13447
|
+
/**
|
|
13448
|
+
* 3.6.0 (ADR 0191): the business analyst's shaping of a change's stories, in plain words. A
|
|
13449
|
+
* rename keeps the story's number; a split's first part keeps it and each other part gets the next
|
|
13450
|
+
* free one; a merge keeps the first story's; an added story gets the next free one. The AI maps
|
|
13451
|
+
* the tasks to the stories at the next draft, and the critic checks none is left without a story.
|
|
13452
|
+
*/
|
|
13453
|
+
export declare const StoryShapeOp: z.ZodEnum<{
|
|
13454
|
+
split: "split";
|
|
13455
|
+
add: "add";
|
|
13456
|
+
merge: "merge";
|
|
13457
|
+
rename: "rename";
|
|
13458
|
+
}>;
|
|
13459
|
+
export declare const StoryShapeRequest: z.ZodObject<{
|
|
13460
|
+
op: z.ZodEnum<{
|
|
13461
|
+
split: "split";
|
|
13462
|
+
add: "add";
|
|
13463
|
+
merge: "merge";
|
|
13464
|
+
rename: "rename";
|
|
10717
13465
|
}>;
|
|
10718
|
-
|
|
10719
|
-
|
|
10720
|
-
|
|
10721
|
-
|
|
10722
|
-
|
|
10723
|
-
|
|
13466
|
+
story: z.ZodOptional<z.ZodString>;
|
|
13467
|
+
stories: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
13468
|
+
name: z.ZodString;
|
|
13469
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13470
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
13471
|
+
name: z.ZodString;
|
|
13472
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13473
|
+
}, z.core.$strict>>>;
|
|
13474
|
+
}, z.core.$strict>;
|
|
13475
|
+
export declare const StoryShapeEntryView: z.ZodObject<{
|
|
13476
|
+
id: z.ZodString;
|
|
13477
|
+
op: z.ZodEnum<{
|
|
13478
|
+
split: "split";
|
|
13479
|
+
add: "add";
|
|
13480
|
+
merge: "merge";
|
|
13481
|
+
rename: "rename";
|
|
13482
|
+
}>;
|
|
13483
|
+
story: z.ZodOptional<z.ZodString>;
|
|
13484
|
+
stories: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
13485
|
+
name: z.ZodString;
|
|
13486
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13487
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
13488
|
+
id: z.ZodString;
|
|
13489
|
+
name: z.ZodString;
|
|
13490
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13491
|
+
}, z.core.$strip>>>;
|
|
13492
|
+
added: z.ZodOptional<z.ZodString>;
|
|
13493
|
+
by: z.ZodString;
|
|
13494
|
+
at: z.ZodString;
|
|
10724
13495
|
state: z.ZodEnum<{
|
|
10725
|
-
|
|
10726
|
-
prepared: "prepared";
|
|
13496
|
+
applied: "applied";
|
|
10727
13497
|
waiting: "waiting";
|
|
10728
|
-
produced: "produced";
|
|
10729
|
-
validated: "validated";
|
|
10730
|
-
cancelled: "cancelled";
|
|
10731
13498
|
}>;
|
|
10732
|
-
|
|
10733
|
-
|
|
10734
|
-
|
|
10735
|
-
|
|
10736
|
-
|
|
10737
|
-
|
|
10738
|
-
|
|
10739
|
-
|
|
10740
|
-
|
|
10741
|
-
|
|
10742
|
-
|
|
13499
|
+
run: z.ZodOptional<z.ZodString>;
|
|
13500
|
+
}, z.core.$strip>;
|
|
13501
|
+
export declare const StoryShapeView: z.ZodObject<{
|
|
13502
|
+
change: z.ZodString;
|
|
13503
|
+
file: z.ZodString;
|
|
13504
|
+
entries: z.ZodArray<z.ZodObject<{
|
|
13505
|
+
id: z.ZodString;
|
|
13506
|
+
op: z.ZodEnum<{
|
|
13507
|
+
split: "split";
|
|
13508
|
+
add: "add";
|
|
13509
|
+
merge: "merge";
|
|
13510
|
+
rename: "rename";
|
|
10743
13511
|
}>;
|
|
10744
|
-
|
|
10745
|
-
|
|
13512
|
+
story: z.ZodOptional<z.ZodString>;
|
|
13513
|
+
stories: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
13514
|
+
name: z.ZodString;
|
|
13515
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13516
|
+
parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
13517
|
+
id: z.ZodString;
|
|
13518
|
+
name: z.ZodString;
|
|
13519
|
+
words: z.ZodOptional<z.ZodString>;
|
|
13520
|
+
}, z.core.$strip>>>;
|
|
13521
|
+
added: z.ZodOptional<z.ZodString>;
|
|
13522
|
+
by: z.ZodString;
|
|
13523
|
+
at: z.ZodString;
|
|
10746
13524
|
state: z.ZodEnum<{
|
|
10747
|
-
|
|
10748
|
-
|
|
10749
|
-
running: "running";
|
|
10750
|
-
stopped: "stopped";
|
|
13525
|
+
applied: "applied";
|
|
13526
|
+
waiting: "waiting";
|
|
10751
13527
|
}>;
|
|
10752
|
-
|
|
10753
|
-
|
|
10754
|
-
|
|
10755
|
-
|
|
10756
|
-
|
|
10757
|
-
|
|
10758
|
-
|
|
10759
|
-
sessions: z.ZodNumber;
|
|
10760
|
-
}, z.core.$strip>;
|
|
10761
|
-
model: z.ZodOptional<z.ZodString>;
|
|
10762
|
-
jobId: z.ZodString;
|
|
10763
|
-
totals: z.ZodObject<{
|
|
10764
|
-
kept: z.ZodNumber;
|
|
10765
|
-
rejected: z.ZodNumber;
|
|
10766
|
-
tokens: z.ZodNumber;
|
|
10767
|
-
}, z.core.$strip>;
|
|
10768
|
-
}, z.core.$strip>;
|
|
10769
|
-
}, z.core.$strip>, z.ZodObject<{
|
|
10770
|
-
type: z.ZodLiteral<"copilot-run.lines">;
|
|
10771
|
-
runId: z.ZodString;
|
|
10772
|
-
tab: z.ZodString;
|
|
10773
|
-
title: z.ZodString;
|
|
10774
|
-
at: z.ZodNumber;
|
|
10775
|
-
lines: z.ZodArray<z.ZodString>;
|
|
10776
|
-
}, z.core.$strip>], "type">;
|
|
13528
|
+
run: z.ZodOptional<z.ZodString>;
|
|
13529
|
+
}, z.core.$strip>>;
|
|
13530
|
+
assigned: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
13531
|
+
uncovered: z.ZodArray<z.ZodString>;
|
|
13532
|
+
command: z.ZodString;
|
|
13533
|
+
}, z.core.$strip>;
|
|
13534
|
+
export type StoryShapeViewT = z.infer<typeof StoryShapeView>;
|
|
10777
13535
|
/** Build the OpenAPI 3.1 document from the zod schemas. */
|
|
10778
13536
|
export declare function openApiDocument(): Record<string, unknown>;
|