@codingame/monaco-vscode-api 33.0.8 → 34.0.0

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/actions.d.ts

@@ -0,0 +1,103 @@
+import { ActionType } from "../common/actions.js";
+import type { ErrorInfo } from "../common/state.js";
+import { ChangesetStatus, type ChangesetFile, type ChangesetOperation, type ChangesetOperationStatus } from "./state.js";
+/**
+ * The {@link ChangesetState.status} for this changeset transitioned (e.g.
+ * `computing → ready`). The error payload is set together with `status`
+ * whenever it transitions to {@link ChangesetStatus.Error | Error}.
+ *
+ * @category Changeset Actions
+ * @version 2
+ */
+export interface ChangesetStatusChangedAction {
+    type: ActionType.ChangesetStatusChanged;
+    /** New computation lifecycle status. */
+    status: ChangesetStatus;
+    /** Cause when `status === ChangesetStatus.Error`; otherwise omitted. */
+    error?: ErrorInfo;
+}
+/**
+ * Upsert a {@link ChangesetFile} in the changeset — adds a new entry, or
+ * replaces an existing one identified by {@link ChangesetFile.id}.
+ *
+ * @category Changeset Actions
+ * @version 2
+ */
+export interface ChangesetFileSetAction {
+    type: ActionType.ChangesetFileSet;
+    /** The new or replacement file entry. */
+    file: ChangesetFile;
+}
+/**
+ * Remove a {@link ChangesetFile} from the changeset by its id.
+ *
+ * Typically dispatched when a file is reverted, staged out, or otherwise
+ * no longer in scope (e.g. a renamed file is replaced by a new entry).
+ *
+ * @category Changeset Actions
+ * @version 2
+ */
+export interface ChangesetFileRemovedAction {
+    type: ActionType.ChangesetFileRemoved;
+    /** The {@link ChangesetFile.id} of the file to remove. */
+    fileId: string;
+}
+/**
+ * The set of operations available on this changeset changed. Full
+ * replacement semantics: `operations` replaces the previous list (or
+ * removes it entirely when `operations` is `undefined`).
+ *
+ * @category Changeset Actions
+ * @version 2
+ */
+export interface ChangesetOperationsChangedAction {
+    type: ActionType.ChangesetOperationsChanged;
+    /** Updated operation list. Pass `undefined` to clear all operations. */
+    operations: ChangesetOperation[] | undefined;
+}
+/**
+ * The {@link ChangesetOperation.status} for a single operation transitioned
+ * (e.g. `idle → running → idle`, or `running → error`). The error payload
+ * is set together with `status` whenever it transitions to
+ * {@link ChangesetOperationStatus.Error | Error}, and cleared on any other
+ * transition.
+ *
+ * Targets one operation by its {@link ChangesetOperation.id}. If no
+ * operation with that id is currently present in the changeset, the action
+ * is a no-op. Use {@link ChangesetOperationsChangedAction} to add, remove,
+ * or otherwise replace the operation list itself.
+ *
+ * @category Changeset Actions
+ * @version 3
+ */
+export interface ChangesetOperationStatusChangedAction {
+    type: ActionType.ChangesetOperationStatusChanged;
+    /** The {@link ChangesetOperation.id} whose status changed. */
+    operationId: string;
+    /** New execution status. */
+    status: ChangesetOperationStatus;
+    /** Cause when `status === ChangesetOperationStatus.Error`; otherwise omitted. */
+    error?: ErrorInfo;
+}
+/**
+ * Drop every file from the changeset.
+ *
+ * Two cases use this:
+ * 1. The underlying source moved (branch switched, fork point invalidated,
+ *    …) and the server is recomputing from scratch — subsequent
+ *    {@link ChangesetFileSetAction} entries will repopulate it.
+ * 2. The owning session has ended and the URI is becoming
+ *    un-subscribable — the server will unsubscribe all clients shortly
+ *    after dispatching this action.
+ *
+ * Clients SHOULD release any references on receipt and SHOULD NOT
+ * distinguish the two cases from the action alone — instead, react to
+ * the corresponding session-level lifecycle signal (e.g.
+ * `root/sessionRemoved`) for the "going away" case.
+ *
+ * @category Changeset Actions
+ * @version 2
+ */
+export interface ChangesetClearedAction {
+    type: ActionType.ChangesetCleared;
+}

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/commands.d.ts

@@ -0,0 +1,97 @@
+import type { URI, ContentRef, StringOrMarkdown, TextRange } from "../common/state.js";
+import type { BaseParams } from "../common/commands.js";
+/**
+ * Discriminator for {@link ChangesetOperationTarget}. Mirrors the
+ * non-`Changeset` members of {@link ChangesetOperationScope} — the
+ * `Changeset` scope has no target.
+ *
+ * @category Commands
+ */
+export declare enum ChangesetOperationTargetKind {
+    /** Operation acts on a single file. */
+    Resource = "resource",
+    /** Operation acts on a line range within a single file. */
+    Range = "range"
+}
+/**
+ * Identifies the file or range a {@link ChangesetOperation} should act on.
+ *
+ * The `kind` MUST match one of the operation's declared
+ * {@link ChangesetOperation.scopes}.
+ *
+ * @category Commands
+ */
+export type ChangesetOperationTarget = {
+    kind: ChangesetOperationTargetKind.Resource;
+    resource: URI;
+    side?: "before" | "after";
+} | {
+    kind: ChangesetOperationTargetKind.Range;
+    resource: URI;
+    side?: "before" | "after";
+    range: TextRange;
+};
+/**
+ * Optional follow-up surfaced by the server after an operation completes —
+ * a {@link ContentRef} the client can fetch and display.
+ *
+ * Set `external` to `true` to open the content in the user's preferred
+ * external handler (e.g. browser); otherwise the client is expected to
+ * surface it inline.
+ *
+ * @category Commands
+ */
+export interface ChangesetOperationFollowUp {
+    content: ContentRef;
+    /** When `true`, open in an external handler rather than inline. */
+    external?: boolean;
+}
+/**
+ * Invokes a server-defined {@link ChangesetOperation} against a changeset,
+ * a single file, or a line range.
+ *
+ * The server validates that `operationId` exists in the changeset's
+ * current `operations` list and that the requested `target.kind` is
+ * contained in the operation's `scopes`. Invalid combinations result in a
+ * JSON-RPC error.
+ *
+ * State changes resulting from invocation flow back through the normal
+ * `changeset/*` action stream on the relevant changeset URIs. Clients
+ * SHOULD NOT synthesise local optimistic changes for invocations unless
+ * the server explicitly opts in via a future capability.
+ *
+ * @category Commands
+ * @method invokeChangesetOperation
+ * @direction Client → Server
+ * @messageType Request
+ * @version 2
+ */
+export interface InvokeChangesetOperationParams extends BaseParams {
+    /** The expanded changeset URI. */
+    channel: URI;
+    /** Matches {@link ChangesetOperation.id} from the changeset's `operations` list. */
+    operationId: string;
+    /**
+     * Target of the operation. Required iff the chosen scope is
+     * `'resource'` or `'range'`. Omit for changeset-scoped operations.
+     */
+    target?: ChangesetOperationTarget;
+}
+/**
+ * Result of the {@link InvokeChangesetOperationParams | `invokeChangesetOperation`}
+ * command.
+ *
+ * Success is implicit: the server returns this result when it accepted
+ * the operation. Failure is signalled by rejecting the JSON-RPC request
+ * with an appropriate error code, not by any field on this result. The
+ * operation MAY still produce subsequent failure feedback through the
+ * {@link ChangesetStatusChangedAction | `changeset/statusChanged`} stream.
+ *
+ * @category Commands
+ */
+export interface InvokeChangesetOperationResult {
+    /** Optional human-readable message describing the result. */
+    message?: StringOrMarkdown;
+    /** Optional follow-up: a URI to open (e.g. a PR), a content ref, etc. */
+    followUp?: ChangesetOperationFollowUp;
+}

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/commands.js

@@ -0,0 +1,9 @@
+
+
+var ChangesetOperationTargetKind;
+(function (ChangesetOperationTargetKind) {
+    ChangesetOperationTargetKind["Resource"] = "resource";
+    ChangesetOperationTargetKind["Range"] = "range";
+})(ChangesetOperationTargetKind || (ChangesetOperationTargetKind = {}));
+
+export { ChangesetOperationTargetKind };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/state.d.ts

@@ -0,0 +1,189 @@
+import type { StringOrMarkdown, FileEdit, ErrorInfo } from "../common/state.js";
+/**
+ * Catalogue entry describing one changeset the server can produce for a
+ * session.
+ *
+ * Catalogue entries are intentionally lightweight — just enough to render a
+ * chip or list row without subscribing. Full per-changeset detail
+ * ({@link ChangesetState}) lives on the subscribable URI obtained by
+ * expanding {@link uriTemplate}.
+ *
+ * @category Changesets
+ */
+export interface ChangesetSummary {
+    /** Human-readable label, e.g. `"Uncommitted Changes"`. */
+    label: string;
+    /**
+     * RFC 6570 URI template. Clients parse the variables directly out of the
+     * template using the standard `{name}` syntax — they are not redeclared
+     * here.
+     *
+     * Only the following template shapes are defined by this protocol; any
+     * other variable name MUST be ignored by clients (there is no
+     * protocol-defined way to obtain values for unknown variables):
+     *
+     * | Variables in template                       | Meaning                                                                              |
+     * | ------------------------------------------- | ------------------------------------------------------------------------------------ |
+     * | _(none)_                                    | A static, session-wide changeset. The template is itself a subscribable URI.         |
+     * | `{turnId}`                                  | Per-turn slice. Expand with a `Turn.id` from the session.                            |
+     * | `{originalTurnId}` and `{modifiedTurnId}`   | Diff between two turns. Both variables MUST be present.                              |
+     *
+     * Future protocol versions MAY add new well-known variables.
+     */
+    uriTemplate: string;
+    /** Optional longer description. */
+    description?: string;
+    /** Aggregate line additions across the changeset, when known. */
+    additions?: number;
+    /** Aggregate line deletions across the changeset, when known. */
+    deletions?: number;
+    /** Number of files in the changeset, when known. */
+    files?: number;
+}
+/**
+ * Computation lifecycle of a {@link ChangesetState}.
+ *
+ * @category Changesets
+ */
+export declare enum ChangesetStatus {
+    /** The server is still computing the contents of this changeset. */
+    Computing = "computing",
+    /** The changeset has been fully computed and is up-to-date. */
+    Ready = "ready",
+    /**
+     * Computation failed. The cause is described by
+     * {@link ChangesetState.error}.
+     */
+    Error = "error"
+}
+/**
+ * Full state for a single changeset, returned when a client subscribes to
+ * an expanded changeset URI.
+ *
+ * The client already knows the URI it subscribed to, so this state does
+ * not redundantly carry it (or the catalogue's `id`, `label`, etc.).
+ * Aggregate counts (`additions`, `deletions`, `files`) are likewise
+ * omitted: clients trivially compute them from `files[].edit.diff`.
+ *
+ * @category Changesets
+ */
+export interface ChangesetState {
+    /** Computation lifecycle. */
+    status: ChangesetStatus;
+    /** Present iff `status === ChangesetStatus.Error`. */
+    error?: ErrorInfo;
+    /** Files in this changeset, keyed by {@link ChangesetFile.id}. */
+    files: ChangesetFile[];
+    /**
+     * Operations the client may invoke against this changeset. Omit when no
+     * operations are available.
+     */
+    operations?: ChangesetOperation[];
+}
+/**
+ * One file entry within a {@link ChangesetState}.
+ *
+ * @category Changesets
+ */
+export interface ChangesetFile {
+    /**
+     * Stable identifier within the changeset. Typically `after.uri`
+     * (or `before.uri` for deletions).
+     */
+    id: string;
+    /**
+     * Reuses the existing {@link FileEdit} shape. Clients derive line
+     * additions, deletions, and rename/create/delete semantics from this.
+     */
+    edit: FileEdit;
+    /**
+     * Server-defined opaque metadata, surfaced to operations and tooling
+     * but not interpreted by the protocol.
+     */
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Execution lifecycle of a {@link ChangesetOperation}.
+ *
+ * An operation is invoked imperatively via `invokeChangesetOperation`, but
+ * its progress and outcome are reflected back into changeset state so that
+ * every subscriber observes a consistent view (e.g. a spinner on a "Create
+ * Pull Request" button, or an inline error after a failed "revert").
+ *
+ * @category Changesets
+ */
+export declare enum ChangesetOperationStatus {
+    /**
+     * The operation is ready to be invoked. This is the default when
+     * {@link ChangesetOperation.status} is omitted.
+     */
+    Idle = "idle",
+    /** An invocation of this operation is currently in flight. */
+    Running = "running",
+    /**
+     * The most recent invocation failed. The cause is described by
+     * {@link ChangesetOperation.error}.
+     */
+    Error = "error"
+}
+/**
+ * Where a {@link ChangesetOperation} can be invoked.
+ *
+ * @category Changesets
+ */
+export declare enum ChangesetOperationScope {
+    /** Applies to the whole changeset. */
+    Changeset = "changeset",
+    /** Applies to a single file within the changeset. */
+    Resource = "resource",
+    /** Applies to a line range within a single file. */
+    Range = "range"
+}
+/**
+ * A server-declared invokable verb the client can run against a
+ * changeset, a file, or a range — `"stage"`, `"revert"`, `"create-pr"`,
+ * and so on.
+ *
+ * The term "operation" is used deliberately to avoid colliding with the
+ * protocol-level [Actions](/guide/actions) that mutate state.
+ *
+ * @category Changesets
+ */
+export interface ChangesetOperation {
+    /** Stable identifier, unique within this changeset. */
+    id: string;
+    /** Human-readable button/menu label. */
+    label: string;
+    /** Optional longer description shown on hover or in tooltips. */
+    description?: string;
+    /** Where this operation can be invoked. */
+    scopes: ChangesetOperationScope[];
+    /**
+     * Optional confirmation prompt to show before invoking. When present,
+     * the client MUST display this message to the user (typically in a
+     * confirmation dialog) and only invoke the operation after the user
+     * accepts. The presence of this field also signals that the operation
+     * is destructive — clients SHOULD style the affirmative button
+     * accordingly (e.g. with a warning colour).
+     */
+    confirmation?: StringOrMarkdown;
+    /** Optional generic icon hint, e.g. `"check"`, `"trash"`. */
+    icon?: string;
+    /**
+     * Current execution status. The server sets
+     * {@link ChangesetOperationStatus.Running | Running} while an invocation
+     * is in flight, {@link ChangesetOperationStatus.Error | Error} when the
+     * most recent invocation failed, and
+     * {@link ChangesetOperationStatus.Idle | Idle} otherwise.
+     *
+     * Clients SHOULD reflect this state in the UI — e.g. disabling the
+     * control or showing a spinner while `Running`, and surfacing
+     * {@link error} while `Error`.
+     */
+    status: ChangesetOperationStatus;
+    /**
+     * Cause of failure. Present iff
+     * `status === ChangesetOperationStatus.Error`; otherwise omitted.
+     */
+    error?: ErrorInfo;
+}

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/state.js

@@ -0,0 +1,22 @@
+
+
+var ChangesetStatus;
+(function (ChangesetStatus) {
+    ChangesetStatus["Computing"] = "computing";
+    ChangesetStatus["Ready"] = "ready";
+    ChangesetStatus["Error"] = "error";
+})(ChangesetStatus || (ChangesetStatus = {}));
+var ChangesetOperationStatus;
+(function (ChangesetOperationStatus) {
+    ChangesetOperationStatus["Idle"] = "idle";
+    ChangesetOperationStatus["Running"] = "running";
+    ChangesetOperationStatus["Error"] = "error";
+})(ChangesetOperationStatus || (ChangesetOperationStatus = {}));
+var ChangesetOperationScope;
+(function (ChangesetOperationScope) {
+    ChangesetOperationScope["Changeset"] = "changeset";
+    ChangesetOperationScope["Resource"] = "resource";
+    ChangesetOperationScope["Range"] = "range";
+})(ChangesetOperationScope || (ChangesetOperationScope = {}));
+
+export { ChangesetOperationScope, ChangesetOperationStatus, ChangesetStatus };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-otlp/notifications.d.ts

@@ -0,0 +1,112 @@
+import type { URI } from "../common/state.js";
+/**
+ * Delivers a batch of OTLP log records to a client subscribed to the host's
+ * logs channel (advertised on `TelemetryCapabilities.logs`).
+ *
+ * The `payload` field is an OTLP/JSON `ExportLogsServiceRequest` value
+ * verbatim — i.e. an object of shape `{ resourceLogs: ResourceLogs[] }` as
+ * defined by [opentelemetry-proto](https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/collector/logs/v1/logs_service.proto).
+ * AHP does not redeclare the OTLP type system; clients SHOULD use an
+ * OpenTelemetry SDK or schema to parse it.
+ *
+ * Like all stateless-channel notifications, this is ephemeral: it is not
+ * replayed on reconnect. Subscribers receive only batches emitted after
+ * their `subscribe` succeeds.
+ *
+ * @category Telemetry Notifications
+ * @method otlp/exportLogs
+ * @direction Server → Client
+ * @messageType Notification
+ * @version 1
+ * @example
+ * ```json
+ * {
+ *   "jsonrpc": "2.0",
+ *   "method": "otlp/exportLogs",
+ *   "params": {
+ *     "channel": "ahp-otlp://logs",
+ *     "payload": { "resourceLogs": [ /* OTLP/JSON ResourceLogs * / ] }
+ *   }
+ * }
+ * ```
+ */
+export interface OtlpExportLogsParams {
+    /** Channel URI this notification belongs to (an `ahp-otlp:` URI advertised on `TelemetryCapabilities.logs`). */
+    channel: URI;
+    /**
+     * OTLP/JSON `ExportLogsServiceRequest` value. The top-level field is
+     * `resourceLogs: ResourceLogs[]`; nested shapes are defined by
+     * opentelemetry-proto and are not redeclared here.
+     */
+    payload: Record<string, unknown>;
+}
+/**
+ * Delivers a batch of OTLP spans to a client subscribed to the host's
+ * traces channel (advertised on `TelemetryCapabilities.traces`).
+ *
+ * The `payload` field is an OTLP/JSON `ExportTraceServiceRequest` value
+ * verbatim — i.e. an object of shape `{ resourceSpans: ResourceSpans[] }`
+ * as defined by [opentelemetry-proto](https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/collector/trace/v1/trace_service.proto).
+ *
+ * @category Telemetry Notifications
+ * @method otlp/exportTraces
+ * @direction Server → Client
+ * @messageType Notification
+ * @version 1
+ * @example
+ * ```json
+ * {
+ *   "jsonrpc": "2.0",
+ *   "method": "otlp/exportTraces",
+ *   "params": {
+ *     "channel": "ahp-otlp://traces",
+ *     "payload": { "resourceSpans": [ /* OTLP/JSON ResourceSpans * / ] }
+ *   }
+ * }
+ * ```
+ */
+export interface OtlpExportTracesParams {
+    /** Channel URI this notification belongs to (an `ahp-otlp:` URI advertised on `TelemetryCapabilities.traces`). */
+    channel: URI;
+    /**
+     * OTLP/JSON `ExportTraceServiceRequest` value. The top-level field is
+     * `resourceSpans: ResourceSpans[]`; nested shapes are defined by
+     * opentelemetry-proto and are not redeclared here.
+     */
+    payload: Record<string, unknown>;
+}
+/**
+ * Delivers a batch of OTLP metric data points to a client subscribed to
+ * the host's metrics channel (advertised on `TelemetryCapabilities.metrics`).
+ *
+ * The `payload` field is an OTLP/JSON `ExportMetricsServiceRequest` value
+ * verbatim — i.e. an object of shape `{ resourceMetrics: ResourceMetrics[] }`
+ * as defined by [opentelemetry-proto](https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/collector/metrics/v1/metrics_service.proto).
+ *
+ * @category Telemetry Notifications
+ * @method otlp/exportMetrics
+ * @direction Server → Client
+ * @messageType Notification
+ * @version 1
+ * @example
+ * ```json
+ * {
+ *   "jsonrpc": "2.0",
+ *   "method": "otlp/exportMetrics",
+ *   "params": {
+ *     "channel": "ahp-otlp://metrics",
+ *     "payload": { "resourceMetrics": [ /* OTLP/JSON ResourceMetrics * / ] }
+ *   }
+ * }
+ * ```
+ */
+export interface OtlpExportMetricsParams {
+    /** Channel URI this notification belongs to (an `ahp-otlp:` URI advertised on `TelemetryCapabilities.metrics`). */
+    channel: URI;
+    /**
+     * OTLP/JSON `ExportMetricsServiceRequest` value. The top-level field is
+     * `resourceMetrics: ResourceMetrics[]`; nested shapes are defined by
+     * opentelemetry-proto and are not redeclared here.
+     */
+    payload: Record<string, unknown>;
+}

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-otlp/state.d.ts

@@ -0,0 +1,57 @@
+import type { URI } from "../common/state.js";
+/**
+ * OTLP telemetry channels the agent host emits.
+ *
+ * Each field, when present, is either a literal channel URI or an
+ * [RFC 6570](https://datatracker.ietf.org/doc/html/rfc6570) URI template
+ * a client expands and then subscribes to. Absent fields indicate the host
+ * does not emit that signal.
+ *
+ * Channel URIs use the `ahp-otlp:` scheme. The scheme identifies the
+ * protocol (OpenTelemetry over AHP) so clients can recognise the channel
+ * type by URI alone; the host is free to choose any authority/path that
+ * makes sense for its implementation. Clients MUST treat the URI as
+ * opaque (apart from expanding any well-known template variables defined
+ * below) and subscribe with the resulting concrete URI.
+ *
+ * Payloads delivered on these channels are OTLP/JSON values — see
+ * [opentelemetry-proto](https://github.com/open-telemetry/opentelemetry-proto)
+ * for the wire shapes (`ExportLogsServiceRequest`,
+ * `ExportTraceServiceRequest`, `ExportMetricsServiceRequest`).
+ *
+ * @category Telemetry
+ */
+export interface TelemetryCapabilities {
+    /**
+     * Channel URI (or RFC 6570 URI template) for OTLP log records
+     * (`otlp/exportLogs` notifications).
+     *
+     * The following template variables are defined by this protocol; any
+     * other variable name MUST be ignored by clients (there is no
+     * protocol-defined way to obtain values for unknown variables):
+     *
+     * | Variables in template | Meaning                                                                                                 |
+     * | --------------------- | ------------------------------------------------------------------------------------------------------- |
+     * | _(none)_              | The host does not support subscriber-side severity filtering. The template is itself a subscribable URI. |
+     * | `{level}`             | Minimum OTLP severity to deliver. Expand to one of the [OTLP `SeverityNumber`](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-severitynumber) short names (case-insensitive): `trace`, `debug`, `info`, `warn`, `error`, `fatal`. The server delivers log records whose `severityNumber` falls in the corresponding band or above. |
+     *
+     * Hosts SHOULD honour the expanded `{level}`; clients MUST still filter
+     * defensively in case a host ignores the parameter. Hosts that do not
+     * advertise `{level}` deliver all severities.
+     *
+     * Future protocol versions MAY add new well-known variables (e.g. scope
+     * or attribute filters).
+     */
+    logs?: URI;
+    /**
+     * Channel URI for OTLP spans (`otlp/exportTraces` notifications). No
+     * template variables are defined by this protocol version.
+     */
+    traces?: URI;
+    /**
+     * Channel URI for OTLP metric data points (`otlp/exportMetrics`
+     * notifications). No template variables are defined by this protocol
+     * version.
+     */
+    metrics?: URI;
+}

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-resource-watch/actions.d.ts

@@ -0,0 +1,21 @@
+import { ActionType } from "../common/actions.js";
+import type { ResourceChange } from "./state.js";
+/**
+ * A batch of resource changes observed by the watcher.
+ *
+ * Watch events are coalesced into batches by the server to keep the
+ * action stream tractable; an empty `changes.items` list MUST NOT be
+ * dispatched. The reducer does not retain change history — these
+ * actions exist purely to deliver events to subscribers, who consume
+ * them directly off the action stream and apply their own logic.
+ *
+ * @category Resource Watch Actions
+ * @version 1
+ */
+export interface ResourceWatchChangedAction {
+    type: ActionType.ResourceWatchChanged;
+    /** The set of changes in this batch, wrapped for forward compatibility. */
+    changes: {
+        items: ResourceChange[];
+    };
+}