ankka-console 0.10.0 → 0.12.0

package/dist/client/schemas.js

@@ -44,6 +44,30 @@ export const whoamiSchema = z.object({
     platformAdmin: z.boolean().default(false),
     organizations: z.array(organizationMembershipSchema).default([]),
 });
+/** The installation's cloud: its provider, account and location, and its key for an owner alone. */
+export const cloudInstallationSchema = z.object({
+    provider: z.string(),
+    account: z.string(),
+    location: z.string(),
+    kmsKey: optional(z.string()),
+});
+/** Where the installation keeps its secrets, and how long the record of reads is kept (feature 038). */
+export const installationSecretsSchema = z.object({
+    backend: z.string(),
+    recordRetention: z.string(),
+    auditLog: z.string().default("unknown"),
+});
+/**
+ * `GET /installation`: the platform's version, and its cloud when it names a provider; and its
+ * backups (feature 041); and where it keeps its secrets (feature 038).
+ */
+export const installationSchema = z.object({
+    platformVersion: z.string(),
+    cloud: optional(cloudInstallationSchema),
+    // Lazily: its schema is with the other backup schemas, below.
+    backups: optional(z.lazy(() => installationStatusSchema)),
+    secrets: optional(installationSecretsSchema),
+});
 export const quotaSchema = z.object({
     projects: optional(z.number().int()),
     services: optional(z.number().int()),
@@ -90,6 +114,40 @@ export const projectSummarySchema = z.object({
     services: z.number().int(),
     registry: optional(registrySummarySchema),
 });
+export const mountStatusSchema = z.object({
+    path: z.string(),
+    service: z.string(),
+    state: z.string().default(""),
+});
+/** One name in a move of a service's secrets to Secret Manager, and how the two compare. */
+export const secretMoveNameSchema = z.object({ name: z.string(), state: z.string() });
+/** What a move of a service's secrets did when its instance started; names and states, never a value. */
+export const secretMoveReportSchema = z.object({
+    phase: z.string(),
+    outcome: z.string(),
+    names: z.array(secretMoveNameSchema).default([]),
+    detail: optional(z.string()),
+});
+/** Where a service's instance keeps its secrets, and what a move of them did. */
+export const secretStoreReportSchema = z.object({
+    backend: z.string(),
+    keyRead: z.boolean(),
+    move: optional(secretMoveReportSchema),
+});
+/** A DNS record a member creates at their provider; the platform writes none. */
+export const dnsRecordSchema = z.object({
+    name: z.string(),
+    kind: z.string(),
+    value: z.string(),
+});
+/** One custom hostname of a service: where it stands, and the record that points it at the installation. */
+export const customHostnameSchema = z.object({
+    hostname: z.string(),
+    state: z.string().default("pending"),
+    reason: optional(z.string()),
+    record: optional(dnsRecordSchema),
+    note: optional(z.string()),
+});
 export const serviceStatusSchema = z.object({
     name: z.string(),
     projectId: z.string(),
@@ -107,6 +165,51 @@ export const serviceStatusSchema = z.object({
     paused: z.boolean().default(false),
     hosting: z.string().default("embedded"),
     protocol: optional(z.string()),
+    mounts: z.array(mountStatusSchema).default([]),
+    callers: z.array(z.string()).default([]),
+    processPort: optional(z.number().int()),
+    broker: optional(z.string()),
+    /** Topics the service's components use that its project does not declare; absent when not read. */
+    undeclaredTopics: optional(z.array(z.string())),
+    /** Where the service keeps its secrets, and what a move of them did, from its instances; absent when not read. */
+    secretStore: optional(secretStoreReportSchema),
+    /** Each side the service takes on a declared topic with a contract, checked against it; absent when not read. */
+    topicChecks: optional(z.array(z.lazy(() => topicCheckSchema))),
+    /** Each topic source of the service with how far behind it is, from its instances; absent when not read. */
+    topicSources: optional(z.array(z.lazy(() => topicSourceReportSchema))),
+    /** What a member should know and need not act on, worked out from the project's declarations now. */
+    warnings: optional(z.array(z.lazy(() => serviceWarningSchema))),
+    objectStorage: optional(z.string()),
+    bucket: optional(z.string()),
+    bucketAddress: optional(z.string()),
+    /** Which store the bucket is in, `garage` or `gcs`, as the operator reported it. */
+    objectStore: optional(z.string()),
+    /** The bucket's location, in Google Cloud Storage. */
+    bucketLocation: optional(z.string()),
+    /** How many days the bucket keeps a deleted object, in Google Cloud Storage. */
+    softDeleteDays: optional(z.number().int()),
+    /** Where a move of the bucket from Garage is, as a phrase; its detail is in `detail`. */
+    storageMove: optional(z.string()),
+    /** The project database cluster the service is on, when a member switched it to a restore. */
+    databaseCluster: optional(z.string()),
+    /** `mounted` when the service's instances read their project's grants (feature 040). */
+    grants: optional(z.string()),
+    /** Each other project's topic the service uses, and whether that project grants it; absent when not read. */
+    crossProjectTopics: optional(z.array(z.lazy(() => crossProjectTopicSchema))),
+    /** Names under domains the project's owner brings, served beside the derived hostname. */
+    customHostnames: z.array(customHostnameSchema).default([]),
+    /** The TXT record that proves the project controls a name it brings; on a read of one service. */
+    proofRecord: optional(dnsRecordSchema),
+});
+/** `POST /services/{project}/{name}/storage/move`: how long the service's writes may be paused. */
+export const storageMoveRequestSchema = z.object({ writePauseBound: optional(z.string()) });
+/** `PUT /projects/{id}/location`. */
+export const setProjectLocationSchema = z.object({ location: z.string() });
+export const crossProjectTopicSchema = z.object({
+    project: z.string(),
+    topic: z.string(),
+    right: z.string(),
+    status: z.string(),
 });
 export const historyActorSchema = z.object({
     subject: z.string(),
@@ -118,7 +221,18 @@ export const historyEntrySchema = z.object({
     generation: z.number().int(),
     actor: optional(historyActorSchema),
     at: optional(z.string()),
+    /** On an entry that recorded a descriptor: its image, and a digest two such entries share exactly when the descriptors are the same. */
+    image: optional(z.string()),
+    digest: optional(z.string()),
+    /** On a custom hostname's entry: the name it added or removed. */
+    hostname: optional(z.string()),
+    /** On a rollback: the generation whose descriptor was applied again. */
+    rolledBackTo: optional(z.number().int()),
+    /** What else the entry says: for a switch, which cluster the service left and which it is on. */
+    detail: optional(z.string()),
 });
+export const rollbackRequestSchema = z.object({ generation: optional(z.number().int()) });
+export const rolledBackSchema = z.object({ rolledBackTo: z.number().int(), status: serviceStatusSchema });
 export const instanceLogsSchema = z.object({
     instance: z.string(),
     output: z.string(),
@@ -127,6 +241,65 @@ export const instanceLogsSchema = z.object({
 export const logsResponseSchema = z.object({
     instances: z.array(instanceLogsSchema),
 });
+// ── Topology ──────────────────────────────────────────────────────────────
+export const topologyHandlerSchema = z.object({
+    name: z.string(),
+    type: z.string(),
+    streaming: optional(z.boolean()),
+});
+export const topologyNodeSchema = z.object({
+    id: z.string(),
+    kind: z.string(),
+    layer: z.number().int(),
+    platform: z.boolean(),
+    handlers: z.array(topologyHandlerSchema),
+});
+export const declaredEdgeSchema = z.object({ from: z.string(), to: z.string(), kind: z.string() });
+export const callPairSchema = z.object({
+    caller: z.string(),
+    callee: z.string(),
+    handled: z.object({ ok: z.number(), refused: z.number(), failed: z.number() }),
+    unanswered: z.object({ timedOut: z.number(), undelivered: z.number() }),
+    durationMillis: z.object({ p50: z.number(), p99: z.number(), max: z.number(), bucketed: z.boolean().default(true) }),
+    streaming: z.boolean().default(false),
+    histogram: z.array(z.number()).default([]),
+});
+export const callEdgeSchema = z.object({ from: z.string(), to: z.string(), pairs: z.array(callPairSchema) });
+export const topologyWindowSchema = z.object({
+    seconds: z.number(),
+    since: z.string(),
+    calls: z.number(),
+    unanswered: z.number().default(0),
+});
+export const instanceTopologyDocumentSchema = z.object({
+    service: z.object({ name: z.string(), runtime: z.string(), instance: z.string(), startedAt: z.string() }),
+    window: topologyWindowSchema,
+    nodes: z.array(topologyNodeSchema),
+    declared: z.array(declaredEdgeSchema),
+    calls: z.array(callEdgeSchema),
+});
+export const instanceStatusSchema = z.enum(["ok", "unreachable", "unsupported", "failed"]);
+export const instanceTopologySchema = z.object({
+    pod: z.string(),
+    status: instanceStatusSchema,
+    problem: optional(z.string()),
+    runtime: optional(z.string()),
+    readAt: optional(z.string()),
+});
+export const topologyDifferenceSchema = z.object({ node: z.string(), presentOn: z.array(z.string()) });
+/** `GET /services/{projectId}/{name}/topology`: every instance's topology, merged. */
+export const serviceTopologySchema = z.object({
+    service: z.string(),
+    running: z.number().int(),
+    contributing: z.number().int(),
+    partial: z.boolean(),
+    instances: z.array(instanceTopologySchema),
+    window: topologyWindowSchema,
+    nodes: z.array(topologyNodeSchema),
+    declared: z.array(declaredEdgeSchema),
+    calls: z.array(callEdgeSchema),
+    differences: z.array(topologyDifferenceSchema),
+});
 export const memberSummarySchema = z.object({
     subject: z.string(),
     role: roleSchema,
@@ -186,11 +359,397 @@ export const setRegistrySchema = z.object({
     username: z.string(),
     password: z.string(),
 });
+/** `PUT /projects/{id}/secrets/{name}`: entries merged into a project secret. */
+export const setProjectSecretSchema = z.object({
+    entries: z.record(z.string(), z.string()),
+});
+/** A contract as declared on a topic: its name and the fingerprint of its schema document. */
+export const contractSchema = z.object({
+    name: z.string(),
+    fingerprint: z.string(),
+});
+/** One side of a declared topic as a running service states it, against the declared contract. */
+export const topicCheckSchema = z.object({
+    topic: optional(z.string()),
+    service: z.string(),
+    component: z.string(),
+    direction: z.string(),
+    stated: optional(z.string()),
+    state: z.string(),
+});
+/**
+ * `PUT /projects/{id}/topics/{name}`: the partitions a declared topic has, whether the broker keeps
+ * only the last message under each key, and the contract it carries with its schema document; and
+ * how long it keeps, how it is cleaned and how many copies it has, each in the words a member types.
+ * A new topic needs its partitions and takes every setting left out from the installation; a topic
+ * already declared keeps what is left out. `removes` restates what a change that removes messages
+ * removes, in the control plane's own words.
+ */
+export const topicDeclarationRequestSchema = z.object({
+    partitions: optional(z.number().int()),
+    compacted: z.boolean().default(false),
+    contract: optional(z.object({ name: z.string(), schema: z.unknown() })),
+    retention: optional(z.string()),
+    retentionSize: optional(z.string()),
+    cleanup: optional(z.string()),
+    tombstoneWindow: optional(z.string()),
+    minCompactionLag: optional(z.string()),
+    maxCompactionLag: optional(z.string()),
+    copies: optional(z.number().int()),
+    minInSync: optional(z.number().int()),
+    removes: optional(z.string()),
+});
+/** A declared topic's every setting in words, and the ones the installation supplied. */
+export const topicSettingsViewSchema = z.object({
+    retention: z.string(),
+    retentionSize: z.string(),
+    cleanup: z.string(),
+    tombstoneWindow: z.string(),
+    minCompactionLag: z.string(),
+    maxCompactionLag: z.string(),
+    copies: optional(z.number().int()),
+    minInSync: optional(z.number().int()),
+    defaulted: z.array(z.string()).default([]),
+});
+/** A topic a project declares, and how far the platform has got with it. */
+export const projectTopicSchema = z.object({
+    name: z.string(),
+    partitions: z.number().int(),
+    phase: optional(z.string()),
+    detail: optional(z.string()),
+    compacted: z.boolean().default(false),
+    contract: optional(contractSchema),
+    checks: z.array(topicCheckSchema).default([]),
+    settings: optional(topicSettingsViewSchema),
+    /** How many copies the broker holds, as the operator last saw. */
+    copiesHeld: optional(z.number().int()),
+    /** How many broker nodes the installation's broker has. */
+    brokerNodes: optional(z.number().int()),
+});
+/** One setting a declaration changed, from what to what. */
+export const settingChangeSchema = z.object({
+    setting: z.string(),
+    from: z.string(),
+    to: z.string(),
+});
+/** Where a partition begins on the broker, and when that message was published. */
+export const partitionGapReportSchema = z.object({
+    partition: z.number().int(),
+    beginning: z.number().int(),
+    earliestRetained: optional(z.string()),
+});
+/** What a topic source's topic no longer holds, per partition, and whether earlier messages are gone. */
+export const retentionGapReportSchema = z.object({
+    partitions: z.array(partitionGapReportSchema),
+    compacted: z.boolean().default(false),
+    gone: z.boolean().default(false),
+    readAt: optional(z.string()),
+});
+/** Something about a service a member should know: a view over a topic that keeps too little. */
+export const serviceWarningSchema = z.object({
+    kind: z.string(),
+    component: z.string(),
+    topic: z.string(),
+    message: z.string(),
+});
+/**
+ * A topic source as a service's instances report it: what reads which topic under which group, the
+ * declared broker and contract it states, `lag` (messages past the last one handled, as of the last
+ * poll) and `failing` (the reason of the change being delivered again, until one succeeds).
+ */
+export const topicSourceReportSchema = z.object({
+    kind: z.string(),
+    component: z.string(),
+    topic: z.string(),
+    group: z.string(),
+    start: z.string(),
+    version: z.number().int(),
+    recordedVersion: optional(z.number().int()),
+    behind: z.boolean().default(false),
+    broker: optional(z.string()),
+    contract: optional(z.string()),
+    lag: optional(z.number().int()),
+    failing: optional(z.string()),
+    /** What the broker still holds of the topic, per partition. */
+    gap: optional(retentionGapReportSchema),
+});
+/** `PUT /projects/{id}/brokers/{name}`: a broker declared beside the installation's, and how it is reached. */
+export const brokerDeclarationRequestSchema = z.object({
+    bootstrap: z.string(),
+    shape: z.string(),
+    secret: z.string(),
+});
+/** A broker a project declares, as listed: where it is, the shape of its credential, and the project secret holding it. */
+export const projectBrokerSchema = z.object({
+    name: z.string(),
+    bootstrap: z.string(),
+    shape: z.string(),
+    secret: z.string(),
+    declaredAt: optional(z.string()),
+});
+/** A project secret as the control plane lists it: entries' names, never a value. */
+export const projectSecretSummarySchema = z.object({
+    name: z.string(),
+    entries: z.array(z.string()),
+    setAt: optional(z.string()),
+    setBy: optional(z.string()),
+});
+/** The record of one read, keep or removal of a service secret: never its value. */
+export const readRecordSchema = z.object({
+    at: z.string(),
+    project: z.string(),
+    service: z.string(),
+    hosting: z.string(),
+    name: z.string(),
+    operation: z.string(),
+    outcome: z.string(),
+    backend: z.string(),
+    traceId: optional(z.string()),
+    spanId: optional(z.string()),
+    component: optional(z.string()),
+    componentKind: optional(z.string()),
+    latestSkipped: z.boolean().default(false),
+});
+/** The record of a project's secret reads, newest first, as an owner reads it. */
+export const secretReadsPageSchema = z.object({ records: z.array(readRecordSchema).default([]) });
+// ── Backups and recovery (feature 041) ──────────────────────────────────────
+/** One line of history's backups: `phase` is `backing up`, `failing` or `not backed up`. */
+export const backupLineSchema = z.object({
+    line: z.string(),
+    cluster: z.string(),
+    phase: z.string(),
+    lastBaseBackup: optional(z.string()),
+    firstRestorable: optional(z.string()),
+    lastRestorable: optional(z.string()),
+    archiveLagSeconds: optional(z.number()),
+    failing: optional(z.string()),
+    copiedAt: optional(z.string()),
+});
+export const projectDatabaseSchema = z.object({
+    cluster: z.string(),
+    instances: z.number().int(),
+    readyInstances: z.number().int(),
+    primary: optional(z.string()),
+    synchronous: z.boolean().default(false),
+    writesWaitingOn: optional(z.string()),
+});
+/** One of the project's database clusters: `live`, a `restore`, or `left` once every service has left it. */
+export const projectClusterSchema = z.object({
+    name: z.string(),
+    line: z.string(),
+    phase: z.string(),
+    services: z.array(z.string()).default([]),
+    since: optional(z.string()),
+    leftAt: optional(z.string()),
+});
+/** What one service's database holds in a restore or a rehearsal; secrets by name only. */
+export const serviceVerificationSchema = z.object({
+    name: z.string(),
+    present: z.boolean(),
+    journalRows: z.number().int().default(0),
+    stateRows: z.number().int().default(0),
+    offsetRows: z.number().int().default(0),
+    timerRows: z.number().int().default(0),
+    highestSequence: z.number().int().default(0),
+    changedSecrets: z.array(z.string()).default([]),
+});
+/** A topic past a restore's moment: messages newer than it, and how many of them a group has read. */
+export const topicDivergenceSchema = z.object({
+    topic: z.string(),
+    group: optional(z.string()),
+    after: z.number().int().default(0),
+    read: optional(z.number().int()),
+    services: z.array(z.string()).default([]),
+});
+/** A restore: `Restoring`, `Verified`, `Failed` or `InUse`, with what each service's database holds. */
+export const restoreViewSchema = z.object({
+    name: z.string(),
+    line: z.string(),
+    moment: z.string(),
+    phase: z.string(),
+    requestedBy: optional(z.string()),
+    requestedAt: optional(z.string()),
+    reachedAt: optional(z.string()),
+    services: z.array(serviceVerificationSchema).default([]),
+    detail: optional(z.string()),
+    broker: z.array(topicDivergenceSchema).default([]),
+    notAsked: z.array(z.string()).default([]),
+    note: optional(z.string()),
+});
+/** A rehearsal: `Running`, `Completed`, `Failed` or `NotRemoved`, and how long it took. */
+export const rehearsalViewSchema = z.object({
+    name: z.string(),
+    line: z.string(),
+    moment: z.string(),
+    outcome: z.string(),
+    requestedBy: optional(z.string()),
+    requestedAt: optional(z.string()),
+    elapsedSeconds: optional(z.number().int()),
+    detail: optional(z.string()),
+    services: z.array(serviceVerificationSchema).default([]),
+});
+export const projectStatusSchema = z.object({
+    id: z.string(),
+    backedUp: z.boolean(),
+    target: z.string(),
+    lines: z.array(backupLineSchema).default([]),
+    database: optional(projectDatabaseSchema),
+    detail: optional(z.string()),
+    clusters: z.array(projectClusterSchema).default([]),
+    restores: z.array(restoreViewSchema).default([]),
+    rehearsal: optional(rehearsalViewSchema),
+});
+export const secondaryStoreSchema = z.object({
+    lastCompleted: optional(z.string()),
+    lastFailed: optional(z.string()),
+    failure: optional(z.string()),
+    buckets: optional(z.number().int()),
+    deletedObjects: optional(z.number().int()),
+});
+export const installationStatusSchema = z.object({
+    backupTarget: z.string(),
+    retentionDays: z.number().int(),
+    copyRequired: z.boolean(),
+    sharesFailureDomain: z.boolean(),
+    encryption: z.string(),
+    controlPlane: optional(backupLineSchema),
+    notBackedUp: optional(z.string()),
+    secondaryStore: optional(secondaryStoreSchema),
+});
+export const serviceDifferenceSchema = z.object({
+    project: z.string(),
+    service: z.string(),
+    recordedGeneration: optional(z.number().int()),
+    clusterGeneration: optional(z.number().int()),
+    recordedImage: optional(z.string()),
+    clusterImage: optional(z.string()),
+});
+/** Whether the control plane is held after its own database was restored, and what differs. */
+export const restoreHoldStatusSchema = z.object({
+    held: z.boolean(),
+    restoredAt: optional(z.string()),
+    targetTime: optional(z.string()),
+    releasedAt: optional(z.string()),
+    releasedBy: optional(z.string()),
+    services: z.array(serviceDifferenceSchema).default([]),
+    topics: z.array(z.string()).default([]),
+    unknownProjects: z.array(z.string()).default([]),
+    reconciled: z.array(z.string()).default([]),
+});
+/** `POST /projects/{id}/restores`: the moment, and the line when services are on more than one. */
+export const restoreRequestSchema = z.object({ moment: z.string(), line: optional(z.string()) });
+/** `POST /services/{p}/{n}/switch`: the cluster to move the service to. */
+export const switchRequestSchema = z.object({ cluster: z.string() });
+/** `POST /projects/{id}/rehearsals`: both may be left out, for the latest restorable moment. */
+export const rehearsalRequestSchema = z.object({ moment: optional(z.string()), line: optional(z.string()) });
+export const credentialReissuedSchema = z.object({ project: z.string(), generation: z.number().int() });
+/** What a project asks of its database, whole. */
+export const databaseSettingSchema = z.object({
+    replicas: z.number().int().default(0),
+    synchronous: z.boolean().default(false),
+    retentionDays: optional(z.number().int()),
+    rehearse: optional(z.string()),
+});
+/**
+ * Who did what to a project: to its database, or to the topic `topic` names, with each setting it
+ * changed (feature 043).
+ */
+export const projectHistoryViewSchema = z.object({
+    kind: z.string(),
+    by: optional(z.string()),
+    at: optional(z.string()),
+    detail: optional(z.string()),
+    topic: optional(z.string()),
+    changes: z.array(settingChangeSchema).default([]),
+});
+// ── Grants and machines (feature 040) ───────────────────────────────────────
+/** What a grant opens: one route, one gRPC method, one topic with one right, or the erasure. */
+export const grantTargetSchema = z.object({
+    kind: z.string(),
+    service: optional(z.string()),
+    method: optional(z.string()),
+    path: optional(z.string()),
+    topic: optional(z.string()),
+    right: optional(z.string()),
+    decrypt: z.boolean().default(false),
+});
+/** Who did something to a grant, and when. */
+export const grantActSchema = z.object({
+    by: optional(z.string()),
+    at: optional(z.string()),
+});
+export const grantRequestSchema = z.object({
+    grantee: z.string(),
+    target: grantTargetSchema,
+});
+/** A grant as its project lists it; `effect` is `in effect`, or why not. */
+export const grantDetailSchema = z.object({
+    id: z.string(),
+    grantee: z.string(),
+    target: grantTargetSchema,
+    state: z.string(),
+    effect: z.string(),
+    granted: grantActSchema,
+    answered: optional(grantActSchema),
+    ended: optional(grantActSchema),
+});
+export const grantChangeRecordSchema = z.object({
+    change: z.string(),
+    by: optional(z.string()),
+    at: optional(z.string()),
+});
+export const topicSettingsSchema = z.object({
+    partitions: z.number().int(),
+    compacted: z.boolean().default(false),
+    retention: optional(z.string()),
+    copies: optional(z.number().int()),
+});
+/** A grant as its grantee's side records it. */
+export const receivedGrantDetailSchema = z.object({
+    id: z.string(),
+    grantingProject: z.string(),
+    grantingOrganization: z.string(),
+    grantee: z.string(),
+    target: grantTargetSchema,
+    state: z.string(),
+    changes: z.array(grantChangeRecordSchema).default([]),
+    topic: optional(topicSettingsSchema),
+});
+export const machineRegistrationSchema = z.object({ name: z.string() });
+/** A machine just registered: its secret, shown this once. */
+export const machineRegisteredSchema = z.object({
+    name: z.string(),
+    clientId: z.string(),
+    clientSecret: z.string(),
+    tokenUrl: z.string(),
+    brokerBootstrap: optional(z.string()),
+});
+export const byteRatesRequestSchema = z.object({
+    produceBytesPerSecond: z.number().int(),
+    consumeBytesPerSecond: z.number().int(),
+    requestPercentage: z.number().int(),
+});
+export const machineSummarySchema = z.object({
+    name: z.string(),
+    clientId: z.string(),
+    registeredBy: optional(z.string()),
+    registeredAt: optional(z.string()),
+    byteRates: optional(byteRatesRequestSchema),
+});
+export const tokenResponseSchema = z.object({
+    access_token: z.string(),
+    token_type: z.string(),
+    expires_in: z.number().int(),
+});
+export const jsonWebKeySetSchema = z.object({
+    keys: z.array(z.object({ kty: z.string(), use: z.string(), alg: z.string(), kid: z.string(), n: z.string(), e: z.string() })),
+});
 /** Every schema by the Scala type's name, as the fixture files name them. */
 export const schemasByType = {
     AuthDiscovery: authDiscoverySchema,
     OrganizationMembership: organizationMembershipSchema,
     Whoami: whoamiSchema,
+    Installation: installationSchema,
     Quota: quotaSchema,
     Usage: usageSchema,
     OrganizationDetail: organizationDetailSchema,
@@ -198,11 +757,19 @@ export const schemasByType = {
     RegistrySummary: registrySummarySchema,
     ProjectDetail: projectDetailSchema,
     ProjectSummary: projectSummarySchema,
+    MountStatus: mountStatusSchema,
     ServiceStatus: serviceStatusSchema,
     HistoryActor: historyActorSchema,
     HistoryEntry: historyEntrySchema,
+    RollbackRequest: rollbackRequestSchema,
+    StorageMoveRequest: storageMoveRequestSchema,
+    SetProjectLocation: setProjectLocationSchema,
+    RolledBack: rolledBackSchema,
     InstanceLogs: instanceLogsSchema,
     LogsResponse: logsResponseSchema,
+    InstanceTopologyDocument: instanceTopologyDocumentSchema,
+    InstanceTopology: instanceTopologySchema,
+    ServiceTopology: serviceTopologySchema,
     MemberSummary: memberSummarySchema,
     InvitationSummary: invitationSummarySchema,
     MembersResponse: membersResponseSchema,
@@ -218,4 +785,32 @@ export const schemasByType = {
     Repair: repairSchema,
     CreateDeployToken: createDeployTokenSchema,
     SetRegistry: setRegistrySchema,
+    SetProjectSecret: setProjectSecretSchema,
+    ProjectSecretSummary: projectSecretSummarySchema,
+    TopicDeclarationRequest: topicDeclarationRequestSchema,
+    ProjectTopic: projectTopicSchema,
+    Contract: contractSchema,
+    BrokerDeclarationRequest: brokerDeclarationRequestSchema,
+    ProjectBroker: projectBrokerSchema,
+    SecretReadsPage: secretReadsPageSchema,
+    ProjectStatus: projectStatusSchema,
+    InstallationStatus: installationStatusSchema,
+    RestoreRequest: restoreRequestSchema,
+    RestoreView: restoreViewSchema,
+    SwitchRequest: switchRequestSchema,
+    ProjectHistoryView: projectHistoryViewSchema,
+    DatabaseSetting: databaseSettingSchema,
+    RehearsalRequest: rehearsalRequestSchema,
+    RehearsalView: rehearsalViewSchema,
+    RestoreHoldStatus: restoreHoldStatusSchema,
+    CredentialReissued: credentialReissuedSchema,
+    GrantRequest: grantRequestSchema,
+    GrantDetail: grantDetailSchema,
+    ReceivedGrantDetail: receivedGrantDetailSchema,
+    MachineRegistration: machineRegistrationSchema,
+    MachineRegistered: machineRegisteredSchema,
+    MachineSummary: machineSummarySchema,
+    ByteRatesRequest: byteRatesRequestSchema,
+    TokenResponse: tokenResponseSchema,
+    JsonWebKeySet: jsonWebKeySetSchema,
 };