// Code generated by seatgen from the seat definitions; DO NOT EDIT.

// The contract of the seat "node-engine", defined whole (seats/node-engine/seat.json): The node seat every node's engine holds (novox/hq ADR 0563, ADR 0618 §3, §4): its hand acts on the operator's warrant, its read-only judgements, its compositions and what it reads of a manifest. Each verb is answered on this node's subject, mesh.seat.node-engine.tool.<verb>.<node>, and each event is published on mesh.seat.node-engine.event.<event>.<node>, the node's name its last token.

export const seat = "node-engine";

export const verbs = {
  handOver: "hand-over",
  accessAct: "access-act",
  judgeDirectories: "judge-directories",
  setuidSearch: "setuid-search",
  rootFree: "root-free",
  acts: "acts",
  packages: "packages",
  composition: "composition",
  compose: "compose",
  composeCandidate: "compose-candidate",
  manifestReads: "manifest-reads",
  seatList: "seat-list",
  seatListAgain: "seat-list-again",
} as const;

export const events = {
  asked: "asked",
  done: "done",
  refused: "refused",
  manifestReadsChanged: "manifest-reads-changed",
} as const;

export const family = { name: "node-engine.events", maxAgeDays: 7 } as const;

export function askedSubject(caller: string): string {
  return "mesh.seat.node-engine.event.asked." + caller;
}

export function doneSubject(caller: string): string {
  return "mesh.seat.node-engine.event.done." + caller;
}

export function refusedSubject(caller: string): string {
  return "mesh.seat.node-engine.event.refused." + caller;
}

export function manifestReadsChangedSubject(caller: string): string {
  return "mesh.seat.node-engine.event.manifest-reads-changed." + caller;
}

export const states = {
  have: "have",
  composed: "composed",
  data: "data",
  packages: "packages",
  health: "health",
  findings: "findings",
} as const;

/** The key of one value of the state have under the form "<node>.<module>". */
export function haveByNodeModuleKey(node: string, module: string): string {
  return node + "." + module;
}

/** The parts of a key of the form "<node>.<module>", or undefined for a key of another form. */
export function parseHaveByNodeModuleKey(_key: string): { node: string; module: string } | undefined {
  let _rest = _key;
  const _at0 = _rest.indexOf(".");
  if (_at0 <= 0) return undefined;
  const node = _rest.slice(0, _at0);
  _rest = _rest.slice(_at0 + 1);
  if (_rest === "") return undefined;
  const module = _rest;
  _rest = "";
  if (_rest !== "") return undefined;
  return { node, module };
}

/** The key of one value of the state have under the form "<node>.node". */
export function haveByNodeNodeKey(node: string): string {
  return node + ".node";
}

/** The parts of a key of the form "<node>.node", or undefined for a key of another form. */
export function parseHaveByNodeNodeKey(_key: string): { node: string } | undefined {
  let _rest = _key;
  const _at0 = _rest.indexOf(".node");
  if (_at0 <= 0) return undefined;
  const node = _rest.slice(0, _at0);
  _rest = _rest.slice(_at0 + 5);
  if (_rest !== "") return undefined;
  return { node };
}

/** The key of one value of the state composed under the form "<node>.<module>.<fingerprint>". */
export function composedByNodeModuleFingerprintKey(node: string, module: string, fingerprint: string): string {
  return node + "." + module + "." + fingerprint;
}

/** The parts of a key of the form "<node>.<module>.<fingerprint>", or undefined for a key of another form. */
export function parseComposedByNodeModuleFingerprintKey(_key: string): { node: string; module: string; fingerprint: string } | undefined {
  let _rest = _key;
  const _at0 = _rest.indexOf(".");
  if (_at0 <= 0) return undefined;
  const node = _rest.slice(0, _at0);
  _rest = _rest.slice(_at0 + 1);
  const _at2 = _rest.indexOf(".");
  if (_at2 <= 0) return undefined;
  const module = _rest.slice(0, _at2);
  _rest = _rest.slice(_at2 + 1);
  if (_rest === "") return undefined;
  const fingerprint = _rest;
  _rest = "";
  if (_rest !== "") return undefined;
  return { node, module, fingerprint };
}

/** The key of one value of the state composed under the form "<node>.node". */
export function composedByNodeNodeKey(node: string): string {
  return node + ".node";
}

/** The parts of a key of the form "<node>.node", or undefined for a key of another form. */
export function parseComposedByNodeNodeKey(_key: string): { node: string } | undefined {
  let _rest = _key;
  const _at0 = _rest.indexOf(".node");
  if (_at0 <= 0) return undefined;
  const node = _rest.slice(0, _at0);
  _rest = _rest.slice(_at0 + 5);
  if (_rest !== "") return undefined;
  return { node };
}

/** The key of one value of the state data under the form "<node>.<module>". */
export function dataByNodeModuleKey(node: string, module: string): string {
  return node + "." + module;
}

/** The parts of a key of the form "<node>.<module>", or undefined for a key of another form. */
export function parseDataByNodeModuleKey(_key: string): { node: string; module: string } | undefined {
  let _rest = _key;
  const _at0 = _rest.indexOf(".");
  if (_at0 <= 0) return undefined;
  const node = _rest.slice(0, _at0);
  _rest = _rest.slice(_at0 + 1);
  if (_rest === "") return undefined;
  const module = _rest;
  _rest = "";
  if (_rest !== "") return undefined;
  return { node, module };
}

/** The key of one value of the state packages under the form "<node>". */
export function packagesByNodeKey(node: string): string {
  return node;
}

/** The parts of a key of the form "<node>", or undefined for a key of another form. */
export function parsePackagesByNodeKey(_key: string): { node: string } | undefined {
  let _rest = _key;
  if (_rest === "") return undefined;
  const node = _rest;
  _rest = "";
  if (_rest !== "") return undefined;
  return { node };
}

/** The key of one value of the state health under the form "<node>". */
export function healthByNodeKey(node: string): string {
  return node;
}

/** The parts of a key of the form "<node>", or undefined for a key of another form. */
export function parseHealthByNodeKey(_key: string): { node: string } | undefined {
  let _rest = _key;
  if (_rest === "") return undefined;
  const node = _rest;
  _rest = "";
  if (_rest !== "") return undefined;
  return { node };
}

/** The key of one value of the state findings under the form "<key>". */
export function findingsByKeyKey(key: string): string {
  return key;
}

/** The parts of a key of the form "<key>", or undefined for a key of another form. */
export function parseFindingsByKeyKey(_key: string): { key: string } | undefined {
  let _rest = _key;
  if (_rest === "") return undefined;
  const key = _rest;
  _rest = "";
  if (_rest !== "") return undefined;
  return { key };
}

/** the hashes of the users of the list, sealed to the vault */
export interface AccountsHanded {
  /** when */
  "at": string;
  "box": SealedBox;
  "from": string;
  /** the fingerprint of the vault's key */
  "to": string;
  "users": number;
}

/** one act asked through the seat, as acts reads it (ADR 0563 §9) */
export interface Act {
  /** the act: hand-over, access-act, judge-directories or setuid-search */
  "act": string;
  /** the operator's ask of a hand-over or an access act */
  "ask"?: string;
  /** when it was asked, RFC 3339 */
  "at": string;
  /** the engine asked it itself, on finding a library's root holding data outside its group (ADR 0563 §4) */
  "auto"?: boolean;
  /** who answered, as the operator's warrant names them */
  "by"?: string;
  /** the caller as the runtime proved it */
  "caller": string;
  /** what the engine read on disk when it judged */
  "disk"?: string;
  /** when it ended, RFC 3339 */
  "ended"?: string;
  /** when the ask ends unanswered, RFC 3339 */
  "expires"?: string;
  /** the act's id */
  "id": string;
  /** the directory the act changes */
  "path"?: string;
  /** the warrant's proofs */
  "proofs"?: string[];
  /** what the engine said of it: its outcome or why it was refused */
  "said"?: string;
  /** the owner, group and mode it sets, in words */
  "sets"?: string;
  /** where it stands */
  "state": "asked" | "done" | "refused" | "answered";
  /** the path of a hand-over, or the access of an access act */
  "subject"?: string;
  /** the channel the warrant came on */
  "via"?: string;
  /** why it was asked, in words */
  "why"?: string;
}

/** what the seat says of an act: the act, the path or access, the caller as the runtime proved it and the ask (ADR 0563 §1) */
export interface ActSaid {
  /** the act */
  "act": string;
  /** the operator's ask */
  "ask"?: string;
  /** the caller as the runtime proved it */
  "caller": string;
  /** the node whose engine says it */
  "node": string;
  /** what the engine said of it */
  "said"?: string;
  /** where the act stands */
  "state": "asked" | "done" | "refused";
  /** the path or the access */
  "subject"?: string;
}

/** the acts kept */
export interface Acts {
  /** the acts, newest first */
  "acts": Act[];
  /** the node */
  "node": string;
}

/** the node is adopted and which of its modules are taken */
export interface Adoption {
  /** the modules taken */
  "taken": string[];
  /** by module, the resources left untaken */
  "untaken"?: Record<string, string[]>;
}

/** the answer of an act the operator is asked */
export interface Asked {
  /** the ask's id: acts shows where it stands */
  "asked": string;
  /** the node */
  "node": string;
  /** what happens next, in words */
  "says": string;
}

/** a network attached to a link */
export interface AttachedNetwork {
  "link": string;
  "network": string;
}

/** a module the candidate adds */
export interface CandidateAdded {
  "composed"?: string;
  "module": string;
  "unissued"?: string[];
}

/** the node's answer to one placement candidate naming it */
export interface CandidateAnswer {
  "added"?: CandidateAdded[];
  "differs"?: CandidateDiffers[];
  "held"?: CandidateRefusal[];
  "note"?: string;
  "proposal": string;
  "refusals"?: CandidateRefusal[];
  /** why the node cannot compose with the candidate at all */
  "refused"?: string;
  /** modules the candidate removes */
  "removed"?: string[];
  "returns"?: string;
  "revision": number;
  /** modules whose composition is the one running */
  "same"?: string[];
  "values_differ"?: number;
  /** same, differs or refused */
  "verdict": "same" | "differs" | "refused";
}

/** the bodies of one resource that differ */
export interface CandidateBodies {
  "composed"?: string;
  "id": string;
  "paths"?: string[];
  "running"?: string;
  "why": string;
}

/** a module whose composition with the candidate differs from the one running */
export interface CandidateDiffers {
  "bodies"?: CandidateBodies[];
  "composed"?: string;
  "module": string;
  "resource"?: string;
  "running"?: string;
  "why": string;
}

/** a module refused or held with the candidate */
export interface CandidateRefusal {
  "module": string;
  "today"?: string;
  "why": string;
}

/** a group */
export interface DeclaredGroup {
  "gid": number;
  "name": string;
}

/** the identity of a module assigned to the node */
export interface DeclaredIdentity {
  "gid": number;
  "groups"?: number[];
  "module": string;
  "name": string;
  "runner"?: string;
  "uid": number;
}

/** a library the node is reached by */
export interface DeclaredLibrary {
  "gid": number;
  "group": string;
  "home": boolean;
  "library": string;
  "paths"?: string[];
  "root": string;
  "runner"?: string;
  "taken"?: boolean;
}

/** a unit that failed */
export interface FailedUnit {
  "load"?: string;
  "resource"?: string;
  "result"?: string;
  "scope": string;
  /** since when */
  "since": string;
  "unit": string;
}

/** one answer the operator may give from a notification */
export interface FindingAction {
  "arguments"?: Record<string, string>;
  "label": string;
  "level"?: "acknowledge" | "approve";
  "machine"?: string;
  /** the seat verb the operator channel calls */
  "verb": string;
}

/** one observation, as it was said */
export interface FindingEvidence {
  "at": string;
  "said": string;
}

/** what the condition is about */
export interface FindingSubject {
  /** the other machines it concerns */
  "also"?: string[];
  /** its id within the scope */
  "id": string;
  /** the machine it concerns, when there is one */
  "machine"?: string;
  /** machine, plan, call, build, merge, provider, seat, bus, core, probe, mesh, delivery or module */
  "scope": string;
}

/** a login that fell back to another node */
export interface LoginFallback {
  /** when */
  "at": string;
  "from": string;
  "node": string;
  "why": string;
}

/** what a node-engine says when what it reads changed or its node returned (ADR 0618 §4) */
export interface ManifestReadsChanged {
  /** when it says it, RFC 3339 */
  "at": string;
  /** what its engine states it reads now */
  "manifest-reads"?: string[];
  /** the node */
  "node": string;
  /** the layout's version */
  "v": number;
  /** started: the engine started or what it states changed; returned: its node returned after being away */
  "why": "started" | "returned";
}

/** one module's composition with the candidate */
export interface Module {
  /** the candidate changes it from the one composed without it */
  "changed"?: boolean;
  /** the composition's digest when composed */
  "digest"?: string;
  /** the fingerprint it was composed at */
  "fp"?: string;
  /** the module, node for the node's own composition */
  "module": string;
  /** composed (digest set), refused by the candidate, or held without it too (words set) */
  "state": "composed" | "refused" | "held";
  /** why, for a refused or held one */
  "words"?: string;
}

/** the node's network */
export interface NetworkHealth {
  "parts": NetworkPart[];
  /** since when */
  "since": string;
  /** running, degraded or unknown */
  "state": string;
}

/** one part of the node's network */
export interface NetworkPart {
  "owner"?: string;
  "part": string;
  "reason"?: string;
  "said"?: string;
  /** since when */
  "since": string;
  "state": string;
  "streak"?: number;
  "targets"?: string[];
  "toward"?: string[];
  "writer"?: string;
}

/** an account the node needs to log in again */
export interface NodeAccount {
  "account": string;
  "module"?: string;
  "reason": string;
  "resource"?: string;
  /** since when */
  "since": string;
}

/** a directory found where the node expected none */
export interface NodeDirectory {
  "module": string;
  "path": string;
  "reason": string;
  "resource": string;
  /** since when */
  "since": string;
}

/** what a node's own composition carries beside its resources */
export interface NodeOwn {
  "adoption"?: Adoption;
  "groups"?: DeclaredGroup[];
  "identities"?: DeclaredIdentity[];
  "libraries"?: DeclaredLibrary[];
  /** the account the provisioner's client runs as on the node */
  "provisioner_account"?: string;
}

/** what the machine observes of itself, for every node and composing part to read */
export interface NodeRecord {
  "authority"?: string;
  "capabilities"?: string[];
  "certificate"?: string;
  "contract"?: number;
  "manifest-reads"?: string[];
  "networks"?: AttachedNetwork[];
  "networks-said"?: boolean;
  "node": string;
  "outward-links"?: string[];
  "sealing-key"?: string;
  "serving-key"?: string;
  "trusts"?: string[];
  "tunnel-key"?: string;
  "v": number;
}

/** a tunnel peer and whether it is seen */
export interface PeerSeen {
  "addresses"?: string[];
  "key": string;
  "seen": boolean;
}

/** one data item a module declares, as placed on a node */
export interface PlacedDataItem {
  "class": string;
  /** the path whose snapshot keeps it, empty when it is not backed up */
  "covered_by"?: string;
  "item": string;
  /** walk, dataset or shallow */
  "measure"?: string;
  "module": string;
  /** the item's place on the node */
  "path": string;
  /** backup, redundancy, both or none */
  "protection"?: string;
}

/** the pull from a store a failed apply waits on */
export interface PullWait {
  /** when the pull began */
  "began": string;
  /** that seat's holder, whose settling the apply waits for */
  "holder": string;
  "image": string;
  /** what triggered the last try again, in words */
  "retried"?: string;
  /** when the apply was last tried again */
  "retried-at"?: string;
  /** the seat the pull came through */
  "seat"?: string;
}

/** one revision of a composition key */
export interface Revision {
  /** its digest */
  "digest"?: string;
  /** the composition's key */
  "key": string;
  /** the latest revision */
  "latest"?: boolean;
  /** why it cannot be read or trusted */
  "refused"?: string;
  /** how many resources it names */
  "resources"?: number;
  /** its revision */
  "revision"?: number;
}

/** the engine's verdict of whether an account's resource is root-free, as the node's health lists it */
export interface RootAccountVerdict {
  "account": string;
  "module": string;
  "reason"?: string;
  "resource": string;
  /** since when */
  "since": string;
  "state": string;
}

/** the engine's root-free verdict (ADR 0563 §6) */
export interface RootVerdict {
  /** the machine is root-free */
  "free": boolean;
  /** when the engine judged it, RFC 3339 */
  "judged": string;
  /** the machine */
  "machine": string;
  /** why, in words */
  "why": string;
}

/** the answer of a read-only judgement */
export interface Said {
  /** the node */
  "node": string;
  /** the engine's judgement or search, one line per directory or program */
  "said": string;
}

/** a value sealed to a key */
export interface SealedBox {
  "ct": string;
  "eph": string;
  "iv": string;
  "tag": string;
  "v": number;
}

export interface SeatListStatus {
  /** the seat mesh-catalog has answered */
  "heard": boolean;
  "held": SeatListHeld[];
  "last-error"?: string;
  /** a trunk definition that does not parse, by seat: the one held stands */
  "refused"?: Record<string, string>;
  "revision"?: number;
  /** the seats held from the bootstrap alone */
  "waiting"?: string[];
}

/** what an engine holds of the seat list (novox/hq ADR 0636 §7) */
export interface SeatList {
  /** why the read failed, for seat-list-again */
  "error"?: string;
  /** the one line the engine says of it; empty when nothing waits */
  "health": string;
  "status": SeatListStatus;
}

export interface SeatListHeld {
  /** the digest of the definition held; empty for a bootstrapped one */
  "digest"?: string;
  "seat": string;
  "source": "trunk" | "bootstrap";
}

/** the node's units */
export interface UnitsHealth {
  "away"?: string[];
  "failed": FailedUnit[];
  "state": string;
  "unread"?: string[];
}

/** the bus's user list as the engine of the bus node wrote it to the bus module's file */
export interface UserListWritten {
  /** when */
  "at": string;
  /** the digest of the file on the machine after the write */
  "digest"?: string;
  /** why a write failed */
  "error"?: string;
  /** which list the node follows now */
  "follows"?: string;
  "handed"?: AccountsHanded;
  /** the bus node's sealing key, its public half */
  "key"?: string;
  "revision": number;
  /** the key the list was taken from */
  "source": string;
  /** why the bus node does not watch the grants part's key now */
  "unwatched"?: string;
  "users": number;
  /** the digest of the list the source holds, sha256:<hex> */
  "wanted": string;
}

/** is what hand-over takes. */
export interface HandOverInput {
  /** the directory's absolute path, as the engine states it */
  "path": string;
  /** why it is asked, in words the operator reads */
  "why"?: string;
}

/** is what hand-over answers. */
export type HandOverAnswer = Asked;

/** is what access-act takes. */
export interface AccessActInput {
  /** the access, library:<name> */
  "access": string;
  /** the act: take */
  "act": string;
  /** why it is asked, in words the operator reads */
  "why"?: string;
}

/** is what access-act answers. */
export type AccessActAnswer = Asked;

/** is what judge-directories takes. */
export interface JudgeDirectoriesInput {
}

/** is what judge-directories answers. */
export type JudgeDirectoriesAnswer = Said;

/** is what setuid-search takes. */
export interface SetuidSearchInput {
  /** why it is asked, in words */
  "why"?: string;
}

/** is what setuid-search answers. */
export type SetuidSearchAnswer = Said;

/** is what root-free takes. */
export interface RootFreeInput {
}

/** is what root-free answers. */
export interface RootFreeAnswer {
  /** this machine's verdict */
  "machines": RootVerdict[];
}

/** is what acts takes. */
export interface ActsInput {
  /** one act, by its id */
  "id"?: string;
  /** at most this many, newest */
  "limit"?: string;
}

/** is what acts answers. */
export type ActsAnswer = Acts;

/** is what packages takes. */
export interface PackagesInput {
  /** "true": write this machine's key again from what the engine composed */
  "write"?: "true" | "false";
}

export interface PackagesAnswerKeyPackagesItem {
  /** declared absent */
  "absent": boolean;
  /** the modules that declare it */
  "modules": string[];
  /** the package */
  "package": string;
}

/** the node's key as the bus holds it; absent when the engine wrote none */
export interface PackagesAnswerKey {
  /** the node */
  "node": string;
  /** its packages sorted by name, absent after present */
  "packages": PackagesAnswerKeyPackagesItem[];
}

/** is what packages answers. */
export interface PackagesAnswer {
  /** the node's key as the bus holds it; absent when the engine wrote none */
  "key"?: PackagesAnswerKey;
  /** why the key could not be read */
  "key_error"?: string;
  /** the node */
  "node": string;
  /** a note, such as that no key is written yet */
  "note"?: string;
  /** where the key is read: the engine's state packages */
  "source": string;
  /** with write: the key was written again (false: it already held what the engine composed) */
  "wrote"?: boolean;
}

/** is what composition takes. */
export interface CompositionInput {
  /** "true": list the resources that differ from what runs */
  "diff"?: string;
  /** a composition's digest (sha256:…), to read that revision rather than the latest */
  "digest"?: string;
  /** the module, as placed on this machine; node for the node's own */
  "module": string;
}

/** the module's last apply that did not end running; absent when none */
export interface CompositionAnswerAttempt {
  /** the want's revision the hold took */
  "answered_revision"?: number;
  /** the digest tried */
  "composed"?: string;
  /** the composition's revision it was tried at */
  "composition_revision": number;
  /** the fingerprint tried */
  "fp": string;
  /** held for a failed backup */
  "held"?: boolean;
  /** it failed because the bus did not answer for a moment */
  "transient"?: boolean;
  /** the want's revision it was tried at */
  "want_revision": number;
}

/** what the module's have key says now; absent when it says nothing */
export interface CompositionAnswerHave {
  /** digest */
  "composed"?: string;
  /** detail */
  "detail"?: string;
  /** fingerprint */
  "fp"?: string;
  /** judgement */
  "judgement"?: string;
  /** running, failed, held or waiting-yes */
  "phase": string;
  /** the digest that waits for a yes */
  "waits"?: string;
}

/** the move from what runs to the composition read */
export interface CompositionAnswerJudged {
  /** the judgement */
  "judgement": string;
  /** the agent would wait for a person's yes before applying it */
  "waits_for_yes": boolean;
  /** its words */
  "words": string;
}

/** of the node's own composition, its own fields beside what runs names */
export interface CompositionAnswerOwn {
  /** the revision's adoption; absent for a converged node */
  "adoption"?: Record<string, unknown>;
  /** groups */
  "groups"?: number;
  /** each module the node's composer held in its last pass, with why */
  "held"?: Record<string, string>;
  /** identities the revision names */
  "identities"?: number;
  /** libraries */
  "libraries"?: number;
  /** the account the provisioner's client runs as, as the revision names it */
  "provisioner_account": string;
  /** as what runs names it */
  "runs_provisioner_account"?: string;
}

/** what runs of the module; absent when nothing runs */
export interface CompositionAnswerRuns {
  /** digest */
  "composed"?: string;
  /** fingerprint */
  "fp"?: string;
  /** applied, have or kept */
  "from": string;
  /** phase */
  "phase"?: string;
  /** how many resources run */
  "resources": number;
}

/** the module's want as the agent holds it; absent when it holds none */
export interface CompositionAnswerWant {
  /** the operator's answer to a failed backup, again or skip */
  "backup"?: string;
  /** the composition's digest it names */
  "composed"?: string;
  /** its build's fingerprint */
  "fp": string;
  /** the module is removed */
  "removed"?: boolean;
  /** the revision of the want's key read last */
  "revision": number;
  /** the node composes the module itself (ADR 0547 §2) */
  "self"?: boolean;
  /** its words */
  "words"?: string;
  /** the digest a person said yes to */
  "yes"?: string;
}

/** is what composition answers. */
export interface CompositionAnswer {
  /** the module's last apply that did not end running; absent when none */
  "attempt"?: CompositionAnswerAttempt;
  "composition": Revision;
  /** every resource that differs from what runs, when asked */
  "diff"?: Record<string, unknown>[];
  /** what the module's have key says now; absent when it says nothing */
  "have"?: CompositionAnswerHave;
  /** the move from what runs to the composition read */
  "judged": CompositionAnswerJudged;
  /** the module */
  "module": string;
  /** the node */
  "node": string;
  /** of the node's own composition, its own fields beside what runs names */
  "own"?: CompositionAnswerOwn;
  /** the revisions of its key the bucket keeps, oldest first */
  "revisions"?: Revision[];
  /** what runs of the module; absent when nothing runs */
  "runs"?: CompositionAnswerRuns;
  /** the agent has looked at the module once since it started */
  "started": boolean;
  /** the module's want as the agent holds it; absent when it holds none */
  "want"?: CompositionAnswerWant;
}

/** is what compose takes. */
export interface ComposeInput {
  /** a module placed on this machine whose apply is also tried again (optional) */
  "module"?: string;
}

/** how the pass went */
export interface ComposeAnswerPass {
  /** when the node composes again on its own, RFC 3339 */
  "again"?: string;
  /** when the pass ended, RFC 3339 */
  "at": string;
  /** the answer is the last pass, made moments ago */
  "earlier"?: boolean;
  /** how many compositions the pass handed the agent that differ from before */
  "handed": number;
  /** each module refused alone, with why */
  "held"?: Record<string, string>;
  /** why the node composed none of its modules */
  "refused"?: string;
}

/** is what compose answers. */
export interface ComposeAnswer {
  /** how the pass went */
  "pass": ComposeAnswerPass;
  /** the module whose apply was tried again */
  "retried"?: string;
}

/** is what compose-candidate takes. */
export interface ComposeCandidateInput {
  /** the key of the indexer's candidate, <group>.<heads hash> */
  "candidate": string;
  /** also answer the composition input the candidate was composed from, for the sandbox path */
  "input"?: boolean;
}

/** is what compose-candidate answers. */
export interface ComposeCandidateAnswer {
  /** the candidate's key */
  "candidate": string;
  /** when asked: the composition input it composed from */
  "input"?: Record<string, unknown>;
  /** every module placed on the node, sorted by name */
  "modules": Module[];
  /** the node */
  "node": string;
  "own": Module;
  /** why the node could not compose with the candidate at all */
  "refused"?: string;
  /** how long the engine took, in milliseconds */
  "took": number;
  /** the layout's version */
  "v": number;
  /** the node's verdict (ADR 0593 §7, §9) */
  "verdict": "composed" | "refused" | "unready" | "not-judged";
}

/** is what manifest-reads takes. */
export interface ManifestReadsInput {
}

/** is what manifest-reads answers. */
export interface ManifestReadsAnswer {
  /** the reader capabilities its engine states: the manifest words, forms and seat names it reads; empty for an engine built before it said them, read as the baseline */
  "manifest-reads"?: string[];
  /** the node */
  "node": string;
  /** when the engine last stated them, RFC 3339 */
  "stated-at": string;
  /** the layout's version */
  "v": number;
}

/** is what seat-list takes. */
export interface SeatListInput {
}

/** is what seat-list answers. */
export type SeatListAnswer = SeatList;

/** is what seat-list-again takes. */
export interface SeatListAgainInput {
}

/** is what seat-list-again answers. */
export type SeatListAgainAnswer = SeatList;

/** is the body of the event asked. */
export type AskedEvent = ActSaid;

/** is the body of the event done. */
export type DoneEvent = ActSaid;

/** is the body of the event refused. */
export type RefusedEvent = ActSaid;

/** is the body of the event manifest-reads-changed. */
export type ManifestReadsChangedEvent = ManifestReadsChanged;

/** is one value of the state have under the key <node>.<module>. */
export interface HaveByNodeModuleValue {
  "build"?: string;
  /** the move changes the build alone */
  "build-alone"?: boolean;
  /** the digest of the composition the node runs */
  "composed"?: string;
  "detail"?: string;
  /** the fingerprint held */
  "fp"?: string;
  "handed"?: AccountsHanded;
  /** what the module's own check says */
  "health": "ok" | "failed" | "waits" | "unknown";
  /** in phase waiting-yes, the judgement of the move */
  "judgement"?: "recreates" | "moves-data" | "cannot-judge";
  /** what the node keeps of the module as it runs */
  "kept"?: string[];
  /** how far it has come */
  "phase": "backing-up" | "applying" | "checking" | "running" | "failed" | "removed" | "held" | "waiting-yes";
  "pull-wait"?: PullWait;
  /** each value sealed to the node's key */
  "sealed"?: string[];
  /** the sealed values by slot */
  "sealed-at"?: Record<string, string>;
  "user-list"?: UserListWritten;
  "v": number;
  /** in phase waiting-yes, the digest of the composition that waits */
  "waits"?: string;
}

/** is one value of the state have under the key <node>.node. */
export interface HaveByNodeNodeValue {
  "busy"?: Record<string, unknown>[];
  /** the node's answer to each placement candidate naming it, by proposal id */
  "candidates"?: Record<string, CandidateAnswer>;
  /** the digest of the node's own composition it runs */
  "composed"?: string;
  /** own, or none (empty) */
  "composes"?: string;
  "composes-why"?: string;
  "filters"?: Record<string, unknown>[];
  "profile"?: Record<string, unknown>;
  "record"?: NodeRecord;
  "sealed"?: string[];
  "sealed-at"?: Record<string, string>;
  "strays"?: Record<string, unknown>[];
  "v": number;
  "windows"?: Record<string, unknown>[];
}

/** is one value of the state composed under the key <node>.<module>.<fingerprint>. */
export interface ComposedByNodeModuleFingerprintValue {
  /** the module declares data */
  "data"?: boolean;
  /** the files the provisioner fills */
  "filled_files"?: string[];
  "fp": string;
  "module": string;
  "node": string;
  /** the module's whole provisioning plan, catalogue.Plan, kept whole: it is the manifest layer's type */
  "plan"?: Record<string, unknown>;
  /** why the module cannot be composed at this fingerprint */
  "refused"?: string;
  /** the declaration resources, each saying its module */
  "resources": Record<string, unknown>[];
  "v": number;
}

/** is one value of the state composed under the key <node>.node. */
export interface ComposedByNodeNodeValue {
  /** the module declares data */
  "data"?: boolean;
  /** the files the provisioner fills */
  "filled_files"?: string[];
  "node": string;
  "own"?: NodeOwn;
  /** the declaration resources, each saying its module */
  "resources": Record<string, unknown>[];
  "v": number;
}

/** is one value of the state data under the key <node>.<module>. */
export interface DataByNodeModuleValue {
  "digest": string;
  "items": PlacedDataItem[];
  "module": string;
  "node": string;
  "v": number;
}

export interface PackagesByNodeValuePackagesItem {
  "absent": boolean;
  "modules": string[];
  "package": string;
}

/** is one value of the state packages under the key <node>. */
export interface PackagesByNodeValue {
  "node": string;
  "packages": PackagesByNodeValuePackagesItem[];
}

/** is one value of the state health under the key <node>. */
export interface HealthByNodeValue {
  /** when */
  "at": string;
  "contract"?: number;
  "fallback"?: LoginFallback;
  "found"?: NodeDirectory[];
  "network"?: NetworkHealth;
  "node": string;
  "peers"?: PeerSeen[];
  "relogin"?: NodeAccount[];
  "root"?: RootAccountVerdict[];
  "units"?: UnitsHealth;
  "v": number;
}

/** is one value of the state findings under the key <key>. */
export interface FindingsByKeyValue {
  "actions"?: FindingAction[];
  "at": string;
  /** newest first, at most 10 */
  "evidence"?: FindingEvidence[];
  "explanation"?: string;
  "headline"?: string;
  /** scope.id.token */
  "key": string;
  "kind": string;
  "needs"?: string;
  /** the module that wrote it */
  "observer": string;
  /** the key's last part when it is not the kind */
  "ref"?: string;
  "resolved"?: string;
  /** self, operator, agent or healer:<name> */
  "resolver"?: string;
  /** what of its own saw it last */
  "run"?: string;
  "severity": "urgent" | "warning";
  /** the row, probe or event that saw it */
  "source": string;
  "subject": FindingSubject;
  /** one line */
  "summary": string;
  /** layout version, 1 */
  "v": number;
}