@rikalabs/akter-cli 0.0.0-stage → 0.1.0-alpha.3

package/dist/cloud-api/runtime.d.ts

@@ -0,0 +1,595 @@
+import * as Framework from "@rikalabs/akter/client";
+import { Schema } from "effect";
+export declare const SidebarCounts: Schema.Struct<{
+    readonly actorTypes: Schema.Int;
+    readonly openDeadLetters: Schema.Int;
+}>;
+export type SidebarCounts = typeof SidebarCounts.Type;
+/**
+ * One environment's runtime at a glance: how many actors there are, the
+ * pending jobs (`inFlight`, queued or waiting to retry) and the dead letters
+ * by job name from the runners' durable views, and from the serving runner's
+ * memory, while it is the only runner, the command rates and turn times
+ * (`perSecond` over the current minute and the four before it, `series24h`
+ * hourly since the runner began recording, `p50Ms` and `p99Ms` over the last
+ * hour, null with no turn), the resident (`awake`) actors and the deepest
+ * mailbox (`depth` 0 and `actor` null when none waits). Each nullable field is
+ * null when the runners do not report it, never zero or empty: throughput and
+ * p99 series, jobs done per hour and the runner, database, socket and
+ * outbox-lag health. `lastDeployAt` is when the environment's newest
+ * deployment was created, null when it has none. `recentDeployments` is null
+ * here; the deployments list reports them with their rollout state.
+ */
+export declare const Overview: Schema.Struct<{
+    readonly commands: Schema.NullOr<Schema.Struct<{
+        readonly perSecond: Schema.Finite;
+        readonly series24h: Schema.$Array<Schema.Struct<{
+            readonly at: Schema.DateTimeUtc;
+            readonly value: Schema.Finite;
+        }>>;
+        readonly p50Ms: Schema.NullOr<Schema.Finite>;
+        readonly p99Ms: Schema.NullOr<Schema.Finite>;
+    }>>;
+    readonly actors: Schema.Struct<{
+        readonly awake: Schema.NullOr<Schema.Int>;
+        readonly total: Schema.Int;
+    }>;
+    readonly jobs: Schema.Struct<{
+        readonly inFlight: Schema.Int;
+        readonly donePerHour: Schema.NullOr<Schema.Int>;
+    }>;
+    readonly deadLettersByJobType: Schema.$Array<Schema.Struct<{
+        readonly jobName: Schema.String;
+        readonly count: Schema.Int;
+    }>>;
+    readonly throughput: Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly at: Schema.DateTimeUtc;
+        readonly value: Schema.Finite;
+    }>>>;
+    readonly p99: Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly at: Schema.DateTimeUtc;
+        readonly value: Schema.Finite;
+    }>>>;
+    readonly health: Schema.Struct<{
+        readonly runners: Schema.NullOr<Schema.Struct<{
+            readonly healthy: Schema.Int;
+            readonly total: Schema.Int;
+        }>>;
+        readonly databaseCpuPercent: Schema.NullOr<Schema.Finite>;
+        readonly maxMailbox: Schema.NullOr<Schema.Struct<{
+            readonly depth: Schema.Int;
+            readonly actor: Schema.NullOr<Schema.String>;
+        }>>;
+        readonly parkedSockets: Schema.NullOr<Schema.Int>;
+        readonly outboxLagP99Ms: Schema.NullOr<Schema.Finite>;
+        readonly lastDeployAt: Schema.NullOr<Schema.DateTimeUtc>;
+    }>;
+    readonly recentDeployments: Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "DeploymentId">;
+        readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+        readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+        readonly environmentHost: Schema.optional<Schema.String>;
+        readonly commitSha: Schema.String;
+        readonly message: Schema.String;
+        readonly author: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly image: Schema.NullOr<Schema.String>;
+        }>;
+        readonly regions: Schema.$Array<Schema.Literals<readonly ["us-east-1", "us-west-2"]>>;
+        readonly runnerCount: Schema.Int;
+        readonly durationMs: Schema.NullOr<Schema.Int>;
+        readonly status: Schema.Literals<readonly ["in-progress", "live", "drained", "rolled-back", "failed"]>;
+        readonly rolledBackFrom: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
+        readonly createdAt: Schema.DateTimeUtc;
+    }>>>;
+}>;
+export type Overview = typeof Overview.Type;
+/**
+ * One actor type and how many actors of it the runners hold. While one runner
+ * serves the deployment, it reports how many of them are resident (`awake`),
+ * the type's command rate over the current minute and the four before it, its
+ * p99 turn time over the last hour (null with no turn) and its deepest
+ * mailbox; otherwise those are null. The commands a type declares are not
+ * reported, so `commands` is null, never empty.
+ */
+export declare const ActorTypeSummary: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly commands: Schema.NullOr<Schema.$Array<Schema.String>>;
+    readonly instances: Schema.Int;
+    readonly awake: Schema.NullOr<Schema.Int>;
+    readonly commandsPerSecond: Schema.NullOr<Schema.Finite>;
+    readonly p99Ms: Schema.NullOr<Schema.Finite>;
+    readonly maxMailbox: Schema.NullOr<Schema.Int>;
+}>;
+export type ActorTypeSummary = typeof ActorTypeSummary.Type;
+/** How far back a series reaches, ending now; the server picks the point spacing for the window. */
+export declare const SeriesWindow: Schema.Literals<readonly ["1h", "24h", "7d"]>;
+export type SeriesWindow = typeof SeriesWindow.Type;
+/** One command's volume over a window: its total and its mean rate. */
+export declare const CommandVolume: Schema.Struct<{
+    readonly command: Schema.String;
+    readonly count: Schema.Int;
+    readonly perSecond: Schema.Finite;
+}>;
+export type CommandVolume = typeof CommandVolume.Type;
+/**
+ * Commands of one actor type over a window, as the serving runner counted the
+ * turns that wrote a receipt. `series` is commands per second at evenly spaced
+ * instants (minutes for `1h`, hours otherwise), oldest first, each the rate
+ * over the part of its interval the runner observed; `commands` is the volume
+ * of each command the type handled in the window, busiest first. `since` is
+ * when the runner began recording: the window holds no point before it.
+ */
+export declare const ActorTypeActivity: Schema.Struct<{
+    readonly window: Schema.Literals<readonly ["1h", "24h", "7d"]>;
+    readonly since: Schema.DateTimeUtc;
+    readonly series: Schema.$Array<Schema.Struct<{
+        readonly at: Schema.DateTimeUtc;
+        readonly value: Schema.Finite;
+    }>>;
+    readonly commands: Schema.$Array<Schema.Struct<{
+        readonly command: Schema.String;
+        readonly count: Schema.Int;
+        readonly perSecond: Schema.Finite;
+    }>>;
+}>;
+export type ActorTypeActivity = typeof ActorTypeActivity.Type;
+/** Turns that finished in at most `upToMs` and more than the previous bucket's bound; the last bucket has a null bound and takes every slower turn. */
+export declare const LatencyBucket: Schema.Struct<{
+    readonly upToMs: Schema.NullOr<Schema.Finite>;
+    readonly count: Schema.Int;
+}>;
+export type LatencyBucket = typeof LatencyBucket.Type;
+/**
+ * How long the turns of one actor type took over a window, from their fenced
+ * read to the database clock after `COMMIT`: buckets in ascending bound order
+ * and the 50th, 95th and 99th percentile in milliseconds, each the bound of
+ * the bucket it falls in capped by the slowest turn, and null when no turn
+ * committed. `since` is when the serving runner began recording.
+ */
+export declare const TurnLatency: Schema.Struct<{
+    readonly window: Schema.Literals<readonly ["1h", "24h", "7d"]>;
+    readonly since: Schema.DateTimeUtc;
+    readonly buckets: Schema.$Array<Schema.Struct<{
+        readonly upToMs: Schema.NullOr<Schema.Finite>;
+        readonly count: Schema.Int;
+    }>>;
+    readonly p50Ms: Schema.NullOr<Schema.Finite>;
+    readonly p95Ms: Schema.NullOr<Schema.Finite>;
+    readonly p99Ms: Schema.NullOr<Schema.Finite>;
+}>;
+export type TurnLatency = typeof TurnLatency.Type;
+/**
+ * One actor of a type. `lastCommand` and `lastActivityAt` are the command and
+ * commit time of its retained receipt with the newest recorded commit time,
+ * null when none records one. `status` is whether it is resident on the
+ * serving runner, null unless that runner is the only one.
+ */
+export declare const ActorInstance: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly status: Schema.NullOr<Schema.Literals<readonly ["awake", "idle"]>>;
+    readonly lastCommand: Schema.NullOr<Schema.String>;
+    readonly lastActivityAt: Schema.NullOr<Schema.DateTimeUtc>;
+    readonly generation: Schema.Int;
+}>;
+export type ActorInstance = typeof ActorInstance.Type;
+export declare const OwnedTableRows: Schema.Struct<{
+    readonly table: Schema.String;
+    readonly columns: Schema.$Array<Schema.String>;
+    readonly rows: Schema.$Array<Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export type OwnedTableRows = typeof OwnedTableRows.Type;
+/**
+ * Whom a command ran as, as the runner recorded it: a `user` with its
+ * `subject` (`user:<id>` or `api-key:<id>` for a command sent from the
+ * console), an `anonymous` caller, or a `system` delivery the framework made
+ * from `source` (an actor's intent, a timer, cron, a workflow, a job or a
+ * subscription), with `subject` the principal of the turn that caused it when
+ * there was one.
+ */
+export declare const CommandCaller: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["user", "anonymous", "system"]>;
+    readonly subject: Schema.NullOr<Schema.String>;
+    readonly source: Schema.NullOr<Schema.String>;
+}>;
+export type CommandCaller = typeof CommandCaller.Type;
+/**
+ * A command receipt the runner still holds. `result` is the outcome's tag
+ * (`Success` or `Failure`), never the stored value, so reading a receipt
+ * reveals that a command ran but not what it returned. `caller` is whom it
+ * ran as, null when the runner's record of the caller does not decode.
+ * `expiresAt` is when the runner stops answering a retry from it. `at` is when
+ * its commit wrote it, on the database clock; null for a receipt written
+ * before runners recorded it. A receipt is the committed turn itself, so
+ * `replayed` is false unless the entry describes an answer served again from
+ * the receipt.
+ */
+export declare const Receipt: Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly command: Schema.String;
+    readonly result: Schema.NullOr<Schema.String>;
+    readonly caller: Schema.NullOr<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["user", "anonymous", "system"]>;
+        readonly subject: Schema.NullOr<Schema.String>;
+        readonly source: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly at: Schema.NullOr<Schema.DateTimeUtc>;
+    readonly expiresAt: Schema.DateTimeUtc;
+    readonly replayed: Schema.Boolean;
+}>;
+export type Receipt = typeof Receipt.Type;
+/**
+ * An event the actor emitted: the cursor and emission time of its newest
+ * retained one, and its subscribers, the event feeds open on it that name the
+ * event, null unless the serving runner is the only one.
+ */
+export declare const ActorEvent: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly cursor: Schema.String;
+    readonly emittedAt: Schema.DateTimeUtc;
+    readonly subscribers: Schema.NullOr<Schema.Int>;
+}>;
+export type ActorEvent = typeof ActorEvent.Type;
+export declare const JobStatus: Schema.Literals<readonly ["queued", "running", "retrying", "done", "dead"]>;
+export type JobStatus = typeof JobStatus.Type;
+export declare const ActorJob: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly id: Schema.String;
+    readonly attempts: Schema.Int;
+    readonly status: Schema.Literals<readonly ["queued", "running", "retrying", "done", "dead"]>;
+}>;
+export type ActorJob = typeof ActorJob.Type;
+/**
+ * One moment of an actor's history: an event it emitted (`label` the event)
+ * or a command whose turn emitted events (`label` the command), both at the
+ * turn's emission time, with `detail` the command id. `caller` is whom the
+ * command ran as, null once its receipt has expired.
+ */
+export declare const ActorTimelineEntry: Schema.Struct<{
+    readonly at: Schema.DateTimeUtc;
+    readonly kind: Schema.Literals<readonly ["command", "event", "job"]>;
+    readonly label: Schema.String;
+    readonly detail: Schema.NullOr<Schema.String>;
+    readonly caller: Schema.NullOr<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["user", "anonymous", "system"]>;
+        readonly subject: Schema.NullOr<Schema.String>;
+        readonly source: Schema.NullOr<Schema.String>;
+    }>>;
+}>;
+export type ActorTimelineEntry = typeof ActorTimelineEntry.Type;
+/**
+ * One actor as the inspector shows it, read from the runner that owns it.
+ * `state` is the committed state, one field per stored entry, and null when
+ * an entry does not decode. `timeline` is its newest timeline page. While one
+ * runner serves the deployment, it reports whether the actor is resident
+ * (`awake`), its open sockets, its mailbox depth (0 when idle), and, while it
+ * is awake, the runner's name and region as the runner was configured. Every
+ * other nullable field is null when the runner does not report it: the turn
+ * count, owned-table rows, and those live fields with more than one runner.
+ * A null is unknown, never zero or empty.
+ */
+export declare const ActorInspector: Schema.Struct<{
+    readonly address: Schema.String;
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly turn: Schema.NullOr<Schema.Int>;
+    readonly tables: Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly table: Schema.String;
+        readonly columns: Schema.$Array<Schema.String>;
+        readonly rows: Schema.$Array<Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>>;
+    readonly receipts: Schema.$Array<Schema.Struct<{
+        readonly commandId: Schema.String;
+        readonly command: Schema.String;
+        readonly result: Schema.NullOr<Schema.String>;
+        readonly caller: Schema.NullOr<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["user", "anonymous", "system"]>;
+            readonly subject: Schema.NullOr<Schema.String>;
+            readonly source: Schema.NullOr<Schema.String>;
+        }>>;
+        readonly at: Schema.NullOr<Schema.DateTimeUtc>;
+        readonly expiresAt: Schema.DateTimeUtc;
+        readonly replayed: Schema.Boolean;
+    }>>;
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly cursor: Schema.String;
+        readonly emittedAt: Schema.DateTimeUtc;
+        readonly subscribers: Schema.NullOr<Schema.Int>;
+    }>>;
+    readonly jobs: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly id: Schema.String;
+        readonly attempts: Schema.Int;
+        readonly status: Schema.Literals<readonly ["queued", "running", "retrying", "done", "dead"]>;
+    }>>;
+    readonly connections: Schema.Struct<{
+        readonly sockets: Schema.NullOr<Schema.Int>;
+        readonly feedCursor: Schema.NullOr<Schema.String>;
+    }>;
+    readonly properties: Schema.Struct<{
+        readonly status: Schema.NullOr<Schema.Literals<readonly ["awake", "idle"]>>;
+        readonly type: Schema.String;
+        readonly generation: Schema.Int;
+        readonly runner: Schema.NullOr<Schema.String>;
+        readonly region: Schema.NullOr<Schema.String>;
+        readonly tenant: Schema.String;
+        readonly mailboxDepth: Schema.NullOr<Schema.Int>;
+    }>;
+    readonly timeline: Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly at: Schema.DateTimeUtc;
+        readonly kind: Schema.Literals<readonly ["command", "event", "job"]>;
+        readonly label: Schema.String;
+        readonly detail: Schema.NullOr<Schema.String>;
+        readonly caller: Schema.NullOr<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["user", "anonymous", "system"]>;
+            readonly subject: Schema.NullOr<Schema.String>;
+            readonly source: Schema.NullOr<Schema.String>;
+        }>>;
+    }>>>;
+}>;
+export type ActorInspector = typeof ActorInspector.Type;
+export declare const CommandOutcome: Schema.Literals<readonly ["ok", "error", "replayed"]>;
+export type CommandOutcome = typeof CommandOutcome.Type;
+/**
+ * One committed command; `errorTag` is set only when `outcome` is `error`.
+ * The command log is read from the runners' receipts: `at` is when the commit
+ * wrote the receipt and `durationMs` the turn from its fenced read to that
+ * write, both on the database clock and null for a receipt written before
+ * runners recorded them; receipts keep no payload, so `payloadPreview` is
+ * null there. The live stream sends each command as the serving runner
+ * commits it, `at` read after `COMMIT` and `durationMs` through it, with a
+ * preview of at most 256 characters that the runner cut and redacted. `caller`
+ * is as in `Receipt`.
+ */
+export declare const CommandLogEntry: Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly at: Schema.NullOr<Schema.DateTimeUtc>;
+    readonly durationMs: Schema.NullOr<Schema.Finite>;
+    readonly address: Schema.String;
+    readonly command: Schema.String;
+    readonly caller: Schema.NullOr<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["user", "anonymous", "system"]>;
+        readonly subject: Schema.NullOr<Schema.String>;
+        readonly source: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly payloadPreview: Schema.NullOr<Schema.String>;
+    readonly outcome: Schema.Literals<readonly ["ok", "error", "replayed"]>;
+    readonly errorTag: Schema.NullOr<Schema.String>;
+}>;
+export type CommandLogEntry = typeof CommandLogEntry.Type;
+/**
+ * A command the console sends to one actor. `commandId` is the client
+ * idempotency key: when omitted the server mints a new one, and when a caller
+ * resends the same key the control plane reuses its durably assigned command
+ * id. The runner then answers from its stored receipt without running the
+ * command again.
+ */
+export declare const SendCommand: Schema.Struct<{
+    readonly address: Schema.String;
+    readonly command: Schema.String;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly commandId: Schema.optional<Schema.String>;
+}>;
+export type SendCommand = typeof SendCommand.Type;
+/** The actor's return value for a command; `replayed` is true when it came from the stored receipt of an earlier send of the same `commandId`. */
+export declare const CommandSent: Schema.Struct<{
+    readonly commandId: Schema.String;
+    readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly replayed: Schema.Boolean;
+}>;
+export type CommandSent = typeof CommandSent.Type;
+declare const CommandExpired_base: Schema.Class<CommandExpired, Schema.TaggedStruct<"CommandExpired", {
+    readonly commandId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A client key remains expired for 30 days after its runner identity expires; answered 410. */
+export declare class CommandExpired extends CommandExpired_base {
+}
+declare const CommandStreamGap_base: Schema.Class<CommandStreamGap, Schema.TaggedStruct<"CommandStreamGap", {}>, import("effect/Cause").YieldableError>;
+/**
+ * The command stream missed commands: the serving runner no longer held what
+ * came after the last one it sent, or this stream fell too far behind. It ends
+ * the stream, so a client that reconnects knows it has a gap rather than
+ * skipping entries unseen.
+ */
+export declare class CommandStreamGap extends CommandStreamGap_base {
+}
+declare const RunnerDefect_base: Schema.Class<RunnerDefect, Schema.TaggedStruct<"RunnerDefect", {}>, import("effect/Cause").YieldableError>;
+/** A remote runner defect is opaque and must never cause an automatic retry; answered 502. */
+export declare class RunnerDefect extends RunnerDefect_base {
+}
+declare const CommandRefused_base: Schema.Class<CommandRefused, Schema.TaggedStruct<"CommandRefused", {
+    readonly commandId: Schema.String;
+    readonly reasonTag: Schema.String;
+    readonly reason: Schema.Union<readonly [typeof Framework.CommandConflict, typeof Framework.CommandExpired, typeof Framework.InvalidCommandId, typeof Framework.Unauthorized, typeof Framework.ActorUnavailable, typeof Framework.Timeout, typeof Framework.NotCreated, typeof Framework.MailboxFull, typeof Framework.RunnerAtCapacity, typeof Framework.QuotaExceeded, typeof Framework.SessionEnded, typeof Framework.InvalidInput, typeof Framework.TransportError]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The runner refused admission without committing a command receipt; answered
+ * 422. `reason` is the framework's own refusal, already taken out of the
+ * runner's `ActorError` envelope, and `reasonTag` its tag.
+ */
+export declare class CommandRefused extends CommandRefused_base {
+}
+declare const CommandFailed_base: Schema.Class<CommandFailed, Schema.TaggedStruct<"CommandFailed", {
+    readonly commandId: Schema.String;
+    readonly errorTag: Schema.String;
+    readonly error: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly replayed: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The actor ran the command and returned a typed error, answered 422. `errorTag`
+ * and `error` are the actor's own error; `replayed` is as in `CommandSent`.
+ */
+export declare class CommandFailed extends CommandFailed_base {
+}
+declare const QuotaExceeded_base: Schema.Class<QuotaExceeded, Schema.TaggedStruct<"QuotaExceeded", {
+    readonly organizationId: Schema.String;
+    readonly period: Schema.String;
+    readonly cap: Schema.Literals<readonly ["compute", "storage", "connections", "spend"]>;
+    readonly limit: Schema.Finite;
+    readonly used: Schema.Finite;
+    readonly retryAfterMs: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The organization reached one of its plan's hard caps, named by `cap`;
+ * answered 429. It carries the framework's `QuotaExceeded` payload, including
+ * when the period resets as `retryAfterMs`.
+ */
+export declare class QuotaExceeded extends QuotaExceeded_base {
+}
+declare const QuotaUnbound_base: Schema.Class<QuotaUnbound, Schema.TaggedStruct<"QuotaUnbound", {
+    readonly deployment: Schema.String;
+    readonly tenant: Schema.String;
+    readonly reason: Schema.Literals<readonly ["tenant", "account", "plan"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The edge refused a metered command because it cannot bill it: no
+ * organization is bound to the deployment's tenant (`tenant`), the
+ * organization has no billing account (`account`), or its stored plan is not
+ * in the pricing configuration (`plan`); answered 402. It carries the edge's
+ * own `QuotaUnbound` tag and payload. Retrying will not succeed until the
+ * binding is fixed, which is why it is not an `Unavailable`.
+ */
+export declare class QuotaUnbound extends QuotaUnbound_base {
+}
+/**
+ * The edge's usage refusals of a new command: the framework's `QuotaExceeded`,
+ * which names the cap, and the edge's own `QuotaUnbound`.
+ */
+export declare const QuotaErrors: readonly [typeof QuotaExceeded, typeof QuotaUnbound];
+/**
+ * One job name: `retried` counts its pending jobs that have failed at least
+ * one attempt and `dead` its dead letters. Jobs done and their latency are
+ * null when the runners do not report them.
+ */
+export declare const JobTypeStats: Schema.Struct<{
+    readonly jobName: Schema.String;
+    readonly done: Schema.NullOr<Schema.Int>;
+    readonly retried: Schema.Int;
+    readonly dead: Schema.Int;
+    readonly p99Ms: Schema.NullOr<Schema.Finite>;
+}>;
+export type JobTypeStats = typeof JobTypeStats.Type;
+/**
+ * The environment's jobs: pending ones that have not failed an attempt yet
+ * (`queued`) or have (`retrying`), and dead letters. Which jobs are running
+ * and the throughput are null when the runners do not report them.
+ */
+export declare const JobsSummary: Schema.Struct<{
+    readonly queued: Schema.Int;
+    readonly running: Schema.NullOr<Schema.Int>;
+    readonly retrying: Schema.Int;
+    readonly dead: Schema.Int;
+    readonly byType: Schema.$Array<Schema.Struct<{
+        readonly jobName: Schema.String;
+        readonly done: Schema.NullOr<Schema.Int>;
+        readonly retried: Schema.Int;
+        readonly dead: Schema.Int;
+        readonly p99Ms: Schema.NullOr<Schema.Finite>;
+    }>>;
+    readonly throughput: Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly at: Schema.DateTimeUtc;
+        readonly value: Schema.Finite;
+    }>>>;
+}>;
+export type JobsSummary = typeof JobsSummary.Type;
+export declare const DeadLetter: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "DeadLetterId">;
+    readonly jobName: Schema.String;
+    readonly jobId: Schema.String;
+    readonly actor: Schema.String;
+    readonly attempts: Schema.Int;
+    readonly lastError: Schema.String;
+    readonly since: Schema.DateTimeUtc;
+}>;
+export type DeadLetter = typeof DeadLetter.Type;
+/**
+ * One workflow run. `step` is the step it reached last: `index` counts the
+ * distinct steps it has recorded, from 1, so a run showing "step n of m" has
+ * `index` n and `total` m, and `index` never exceeds `total`. `total` is null
+ * when the runner does not know how many steps the workflow has, and `step`
+ * is null when the run holds no recorded step, as once it finished. A failed
+ * run ended with a declared failure, a defect or an interruption. `status` is
+ * null for a finished run whose stored result does not decode.
+ */
+export declare const Workflow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly actor: Schema.String;
+    readonly step: Schema.NullOr<Schema.Struct<{
+        readonly index: Schema.Int;
+        readonly total: Schema.NullOr<Schema.Int>;
+        readonly name: Schema.String;
+    }>>;
+    readonly waitingFor: Schema.NullOr<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["event", "timer"]>;
+        readonly name: Schema.String;
+    }>>;
+    readonly startedAt: Schema.DateTimeUtc;
+    readonly status: Schema.NullOr<Schema.Literals<readonly ["running", "waiting", "completed", "failed"]>>;
+}>;
+export type Workflow = typeof Workflow.Type;
+export declare const TimersSummary: Schema.Struct<{
+    readonly pending: Schema.Int;
+    readonly nextFireAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>;
+export type TimersSummary = typeof TimersSummary.Type;
+/**
+ * One cron entry an actor type declares: `name` is the command it runs,
+ * `actorPattern` the type's actors (`Type/*`) and `cron` the expression as the
+ * runtime keys it. `nextRunAt` is the soonest pending tick of the tenant's
+ * actors of the type, null when none holds one. `lastRun` is the newest tick
+ * that committed, found among the type's newest 10,000 receipts, null when
+ * none is there; its `durationMs` is null when the receipt holds no start.
+ */
+export declare const Schedule: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly actorPattern: Schema.String;
+    readonly cron: Schema.String;
+    readonly lastRun: Schema.NullOr<Schema.Struct<{
+        readonly at: Schema.DateTimeUtc;
+        readonly outcome: Schema.Literals<readonly ["ok", "error"]>;
+        readonly durationMs: Schema.NullOr<Schema.Finite>;
+    }>>;
+    readonly nextRunAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>;
+export type Schedule = typeof Schedule.Type;
+/**
+ * The tenant's open connections on the serving runner, which reports them
+ * only while it is the only runner: `open` counts every WebSocket session and
+ * SSE response, `sseStreams` the SSE responses (event feeds, stream members
+ * and query watches) and `feedSubscribers` the event feeds, overall and by
+ * actor type. Runners do not measure parked connections, replay gaps or their
+ * history, so `parked`, `replayGaps` and `openVersusParked` are null.
+ */
+export declare const ConnectionsSummary: Schema.Struct<{
+    readonly open: Schema.Int;
+    readonly parked: Schema.NullOr<Schema.Int>;
+    readonly sseStreams: Schema.Int;
+    readonly feedSubscribers: Schema.Int;
+    readonly replayGaps: Schema.NullOr<Schema.Int>;
+    readonly openVersusParked: Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly at: Schema.DateTimeUtc;
+        readonly open: Schema.Int;
+        readonly parked: Schema.Int;
+    }>>>;
+    readonly byActorType: Schema.$Array<Schema.Struct<{
+        readonly actorType: Schema.String;
+        readonly open: Schema.Int;
+        readonly parked: Schema.NullOr<Schema.Int>;
+        readonly sse: Schema.Int;
+    }>>;
+}>;
+export type ConnectionsSummary = typeof ConnectionsSummary.Type;
+/**
+ * A command-palette hit among the runtime's own data; pages and settings are
+ * searched client side. An `actor-type` hit's `id` is the type's name and an
+ * `actor` hit's its address.
+ */
+export declare const SearchResult: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["actor-type", "actor", "deployment"]>;
+    readonly id: Schema.String;
+    readonly title: Schema.String;
+    readonly subtitle: Schema.NullOr<Schema.String>;
+}>;
+export type SearchResult = typeof SearchResult.Type;
+export {};