npm - @knpkv/control-center - Versions diffs - 0.1.0 - Mend

@knpkv/control-center 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (664) hide show

package/dist/server/api/liveEvents.d.ts ADDED Viewed

@@ -0,0 +1,1120 @@
+import * as Schema from "effect/Schema";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { ForbiddenApiError, InvalidRequestApiError, RateLimitedApiError, RequestTimedOutApiError, ServiceUnavailableApiError, UnauthorizedApiError } from "./errors.js";
+import { SessionCookieAuth } from "./session.js";
+/** URL/header representation of a nonnegative workspace event cursor. */
+export declare const EventCursorFromString: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+/** Replay boundary telling a client to replace local state with an authoritative snapshot. */
+export declare const StreamResetRequired: Schema.Struct<{
+    readonly reason: Schema.Literals<readonly ["retention", "cursor-ahead", "gap", "replay-budget"]>;
+    readonly requestedCursor: Schema.brand<Schema.Int, "EventCursor">;
+    readonly headCursor: Schema.brand<Schema.Int, "EventCursor">;
+    readonly prunedThroughCursor: Schema.brand<Schema.Int, "EventCursor">;
+}>;
+/** Decoded reset instruction carried by the live event stream. */
+export type StreamResetRequired = typeof StreamResetRequired.Type;
+/** Keepalive payload that reports the latest durable cursor without advancing EventSource state. */
+export declare const StreamHeartbeat: Schema.Struct<{
+    readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+    readonly sentAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded keepalive payload carried by the live event stream. */
+export type StreamHeartbeat = typeof StreamHeartbeat.Type;
+/** Authoritative portfolio replacement emitted first and after replay reset. */
+export declare const PortfolioSnapshotLiveEvent: Schema.Struct<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.snapshot">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly generatedAt: Schema.DateTimeUtcFromString;
+        readonly releases: Schema.$Array<Schema.Struct<{
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly serviceName: Schema.brand<Schema.String, "ReleaseServiceName">;
+            readonly version: Schema.brand<Schema.String, "ReleaseVersion">;
+            readonly lifecycle: Schema.Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+            readonly relay: Schema.Struct<{
+                readonly algorithm: Schema.Literal<"relay/v1">;
+                readonly codename: Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+                readonly symbolIndices: Schema.Tuple<readonly [Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+            }>;
+            readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                readonly _tag: Schema.tag<"current">;
+                readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>]>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"stale">;
+                readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.TaggedStruct<"missing", {
+                readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.TaggedStruct<"unavailable", {
+                readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.Null;
+            }>]>;
+            readonly targetEnvironmentIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+            readonly collaborators: Schema.$Array<Schema.Struct<{
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                readonly displayName: Schema.String;
+                readonly avatarFallback: Schema.String;
+                readonly role: Schema.Literals<readonly ["release-owner", "release-approver"]>;
+            }>>;
+            readonly collaboratorCount: Schema.Int;
+            readonly readiness: Schema.NullOr<Schema.Struct<{
+                readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockerCount: Schema.Int;
+                readonly warningCount: Schema.Int;
+                readonly gapCount: Schema.Int;
+                readonly primaryFinding: Schema.NullOr<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.Struct<{
+                readonly issues: Schema.Int;
+                readonly pullRequests: Schema.Int;
+                readonly pipelineExecutions: Schema.Int;
+                readonly truncated: Schema.Boolean;
+            }>;
+            readonly sourceRevisionCount: Schema.Int;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly plugins: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly providerAccountId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, never, never>;
+            readonly followedResourceId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, never, never>;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly displayName: Schema.String;
+            readonly isEnabled: Schema.Boolean;
+            readonly supportsSynchronization: Schema.decodeTo<Schema.Boolean, Schema.optional<Schema.Boolean>, never, never>;
+            readonly health: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"degraded">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"unavailable">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.TaggedStruct<"disabled", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>]>>;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }>>;
+}>;
+/** Decoded authoritative portfolio stream event. */
+export type PortfolioSnapshotLiveEvent = typeof PortfolioSnapshotLiveEvent.Type;
+/** Durable notification that a browser should refresh its portfolio projection. */
+export declare const PortfolioInvalidatedLiveEvent: Schema.Struct<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.invalidated">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventType: Schema.Literal<"portfolio-invalidated">;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly ingestedAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        readonly metadata: Schema.Struct<{
+            readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+            readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+            readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+        }>;
+    }>>;
+}>;
+/** Decoded portfolio invalidation stream event. */
+export type PortfolioInvalidatedLiveEvent = typeof PortfolioInvalidatedLiveEvent.Type;
+/** Replay-gap instruction; it deliberately has no SSE ID so it cannot advance resume state. */
+export declare const StreamResetRequiredLiveEvent: Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.Undefined>;
+    readonly event: Schema.Literal<"stream.reset-required">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly reason: Schema.Literals<readonly ["retention", "cursor-ahead", "gap", "replay-budget"]>;
+        readonly requestedCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly headCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly prunedThroughCursor: Schema.brand<Schema.Int, "EventCursor">;
+    }>>;
+}>;
+/** Decoded replay-gap stream event. */
+export type StreamResetRequiredLiveEvent = typeof StreamResetRequiredLiveEvent.Type;
+/** Keepalive event; it deliberately has no SSE ID so it cannot advance resume state. */
+export declare const StreamHeartbeatLiveEvent: Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.Undefined>;
+    readonly event: Schema.Literal<"stream.heartbeat">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly sentAt: Schema.DateTimeUtcFromString;
+    }>>;
+}>;
+/** Decoded keepalive stream event. */
+export type StreamHeartbeatLiveEvent = typeof StreamHeartbeatLiveEvent.Type;
+/** Closed browser-safe union emitted by the authenticated live event stream. */
+export declare const ControlCenterLiveEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.snapshot">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly generatedAt: Schema.DateTimeUtcFromString;
+        readonly releases: Schema.$Array<Schema.Struct<{
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly serviceName: Schema.brand<Schema.String, "ReleaseServiceName">;
+            readonly version: Schema.brand<Schema.String, "ReleaseVersion">;
+            readonly lifecycle: Schema.Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+            readonly relay: Schema.Struct<{
+                readonly algorithm: Schema.Literal<"relay/v1">;
+                readonly codename: Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+                readonly symbolIndices: Schema.Tuple<readonly [Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+            }>;
+            readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                readonly _tag: Schema.tag<"current">;
+                readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>]>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"stale">;
+                readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.TaggedStruct<"missing", {
+                readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.TaggedStruct<"unavailable", {
+                readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.Null;
+            }>]>;
+            readonly targetEnvironmentIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+            readonly collaborators: Schema.$Array<Schema.Struct<{
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                readonly displayName: Schema.String;
+                readonly avatarFallback: Schema.String;
+                readonly role: Schema.Literals<readonly ["release-owner", "release-approver"]>;
+            }>>;
+            readonly collaboratorCount: Schema.Int;
+            readonly readiness: Schema.NullOr<Schema.Struct<{
+                readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockerCount: Schema.Int;
+                readonly warningCount: Schema.Int;
+                readonly gapCount: Schema.Int;
+                readonly primaryFinding: Schema.NullOr<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.Struct<{
+                readonly issues: Schema.Int;
+                readonly pullRequests: Schema.Int;
+                readonly pipelineExecutions: Schema.Int;
+                readonly truncated: Schema.Boolean;
+            }>;
+            readonly sourceRevisionCount: Schema.Int;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly plugins: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly providerAccountId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, never, never>;
+            readonly followedResourceId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, never, never>;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly displayName: Schema.String;
+            readonly isEnabled: Schema.Boolean;
+            readonly supportsSynchronization: Schema.decodeTo<Schema.Boolean, Schema.optional<Schema.Boolean>, never, never>;
+            readonly health: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"degraded">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"unavailable">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.TaggedStruct<"disabled", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>]>>;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.invalidated">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventType: Schema.Literal<"portfolio-invalidated">;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly ingestedAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        readonly metadata: Schema.Struct<{
+            readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+            readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+            readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+        }>;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.Undefined>;
+    readonly event: Schema.Literal<"stream.reset-required">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly reason: Schema.Literals<readonly ["retention", "cursor-ahead", "gap", "replay-budget"]>;
+        readonly requestedCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly headCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly prunedThroughCursor: Schema.brand<Schema.Int, "EventCursor">;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.Undefined>;
+    readonly event: Schema.Literal<"stream.heartbeat">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly sentAt: Schema.DateTimeUtcFromString;
+    }>>;
+}>]>;
+/** Decoded browser-safe live event. */
+export type ControlCenterLiveEvent = typeof ControlCenterLiveEvent.Type;
+declare const LiveEventsApiGroup_base: HttpApiGroup.HttpApiGroup<"liveEvents", HttpApiEndpoint.HttpApiEndpoint<"stream", "GET", "/api/v1/events", never, Schema.toCodecStringTree<Schema.Struct<{
+    after: Schema.optionalKey<Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>>;
+}>>, never, Schema.toCodecStringTree<Schema.Struct<{
+    "last-event-id": Schema.optionalKey<Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>>;
+}>>, HttpApiSchema.StreamSse<Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.snapshot">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly generatedAt: Schema.DateTimeUtcFromString;
+        readonly releases: Schema.$Array<Schema.Struct<{
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly serviceName: Schema.brand<Schema.String, "ReleaseServiceName">;
+            readonly version: Schema.brand<Schema.String, "ReleaseVersion">;
+            readonly lifecycle: Schema.Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+            readonly relay: Schema.Struct<{
+                readonly algorithm: Schema.Literal<"relay/v1">;
+                readonly codename: Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+                readonly symbolIndices: Schema.Tuple<readonly [Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+            }>;
+            readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                readonly _tag: Schema.tag<"current">;
+                readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>]>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"stale">;
+                readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.TaggedStruct<"missing", {
+                readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.TaggedStruct<"unavailable", {
+                readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.Null;
+            }>]>;
+            readonly targetEnvironmentIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+            readonly collaborators: Schema.$Array<Schema.Struct<{
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                readonly displayName: Schema.String;
+                readonly avatarFallback: Schema.String;
+                readonly role: Schema.Literals<readonly ["release-owner", "release-approver"]>;
+            }>>;
+            readonly collaboratorCount: Schema.Int;
+            readonly readiness: Schema.NullOr<Schema.Struct<{
+                readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockerCount: Schema.Int;
+                readonly warningCount: Schema.Int;
+                readonly gapCount: Schema.Int;
+                readonly primaryFinding: Schema.NullOr<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.Struct<{
+                readonly issues: Schema.Int;
+                readonly pullRequests: Schema.Int;
+                readonly pipelineExecutions: Schema.Int;
+                readonly truncated: Schema.Boolean;
+            }>;
+            readonly sourceRevisionCount: Schema.Int;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly plugins: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly providerAccountId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, never, never>;
+            readonly followedResourceId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, never, never>;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly displayName: Schema.String;
+            readonly isEnabled: Schema.Boolean;
+            readonly supportsSynchronization: Schema.decodeTo<Schema.Boolean, Schema.optional<Schema.Boolean>, never, never>;
+            readonly health: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"degraded">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"unavailable">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.TaggedStruct<"disabled", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>]>>;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.invalidated">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventType: Schema.Literal<"portfolio-invalidated">;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly ingestedAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        readonly metadata: Schema.Struct<{
+            readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+            readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+            readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+        }>;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.Undefined>;
+    readonly event: Schema.Literal<"stream.reset-required">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly reason: Schema.Literals<readonly ["retention", "cursor-ahead", "gap", "replay-budget"]>;
+        readonly requestedCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly headCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly prunedThroughCursor: Schema.brand<Schema.Int, "EventCursor">;
+    }>>;
+}>, Schema.Struct<{
+    readonly id: Schema.optionalKey<Schema.Undefined>;
+    readonly event: Schema.Literal<"stream.heartbeat">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly sentAt: Schema.DateTimeUtcFromString;
+    }>>;
+}>]>, Schema.Never, Schema.Struct.ReadonlySide<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.snapshot">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly generatedAt: Schema.DateTimeUtcFromString;
+        readonly releases: Schema.$Array<Schema.Struct<{
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly serviceName: Schema.brand<Schema.String, "ReleaseServiceName">;
+            readonly version: Schema.brand<Schema.String, "ReleaseVersion">;
+            readonly lifecycle: Schema.Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+            readonly relay: Schema.Struct<{
+                readonly algorithm: Schema.Literal<"relay/v1">;
+                readonly codename: Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+                readonly symbolIndices: Schema.Tuple<readonly [Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+            }>;
+            readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                readonly _tag: Schema.tag<"current">;
+                readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>]>;
+                readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>]>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"stale">;
+                readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"degraded">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.Struct<{
+                    readonly _tag: Schema.tag<"cache">;
+                    readonly cachedAt: Schema.DateTimeUtcFromString;
+                    readonly sourceRevision: Schema.Struct<{
+                        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                        readonly revision: Schema.brand<Schema.String, "Revision">;
+                        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                    }>;
+                }>;
+                readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+            }>, Schema.TaggedStruct<"missing", {
+                readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.TaggedStruct<"unavailable", {
+                readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"unavailable">;
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly safeMessage: Schema.String;
+                }>, Schema.TaggedStruct<"disabled", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                }>]>;
+                readonly provenance: Schema.TaggedStruct<"none", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly sourceObservedAt: Schema.Null;
+                readonly staleAfterSeconds: Schema.Int;
+                readonly synchronizedAt: Schema.Null;
+            }>]>;
+            readonly targetEnvironmentIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+            readonly collaborators: Schema.$Array<Schema.Struct<{
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                readonly displayName: Schema.String;
+                readonly avatarFallback: Schema.String;
+                readonly role: Schema.Literals<readonly ["release-owner", "release-approver"]>;
+            }>>;
+            readonly collaboratorCount: Schema.Int;
+            readonly readiness: Schema.NullOr<Schema.Struct<{
+                readonly authority: Schema.Literals<readonly ["authoritative", "pending"]>;
+                readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+                readonly stages: Schema.Struct<{
+                    readonly build: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly verify: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly production: Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                        readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly blockerCount: Schema.Int;
+                readonly warningCount: Schema.Int;
+                readonly gapCount: Schema.Int;
+                readonly primaryFinding: Schema.NullOr<Schema.Struct<{
+                    readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                    readonly subject: Schema.TaggedUnion<{
+                        readonly source: Schema.TaggedStruct<"source", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        }>;
+                        readonly fact: Schema.TaggedStruct<"fact", {
+                            readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                        }>;
+                        readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                    }>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                }>>;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.Struct<{
+                readonly issues: Schema.Int;
+                readonly pullRequests: Schema.Int;
+                readonly pipelineExecutions: Schema.Int;
+                readonly truncated: Schema.Boolean;
+            }>;
+            readonly sourceRevisionCount: Schema.Int;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly plugins: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly providerAccountId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">>>, never, never>;
+            readonly followedResourceId: Schema.decodeTo<Schema.toType<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, Schema.optional<Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">>>, never, never>;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly displayName: Schema.String;
+            readonly isEnabled: Schema.Boolean;
+            readonly supportsSynchronization: Schema.decodeTo<Schema.Boolean, Schema.optional<Schema.Boolean>, never, never>;
+            readonly health: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"degraded">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"unavailable">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+                readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly safeMessage: Schema.String;
+            }>, Schema.TaggedStruct<"disabled", {
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>]>>;
+            readonly updatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }>>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly id: Schema.compose<Schema.brand<Schema.Int, "EventCursor">, Schema.decodeTo<Schema.Int, Schema.String, never, never>>;
+    readonly event: Schema.Literal<"portfolio.invalidated">;
+    readonly data: Schema.fromJsonString<Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly eventType: Schema.Literal<"portfolio-invalidated">;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly ingestedAt: Schema.DateTimeUtcFromString;
+        readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+        readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        readonly metadata: Schema.Struct<{
+            readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+            readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+            readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+        }>;
+        readonly payload: Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+        }>;
+    }>>;
+}, "Type"> | {
+    readonly event: "stream.reset-required";
+    readonly data: Schema.Struct.ReadonlySide<{
+        readonly reason: Schema.Literals<readonly ["retention", "cursor-ahead", "gap", "replay-budget"]>;
+        readonly requestedCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly headCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly prunedThroughCursor: Schema.brand<Schema.Int, "EventCursor">;
+    }, "Type">;
+    readonly id?: undefined;
+} | {
+    readonly event: "stream.heartbeat";
+    readonly data: Schema.Struct.ReadonlySide<{
+        readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+        readonly sentAt: Schema.DateTimeUtcFromString;
+    }, "Type">;
+    readonly id?: undefined;
+}>, Schema.toCodecJson<typeof InvalidRequestApiError | typeof UnauthorizedApiError | typeof ForbiddenApiError | typeof RequestTimedOutApiError | typeof RateLimitedApiError | typeof ServiceUnavailableApiError>, SessionCookieAuth, never>, false>;
+/** Authenticated resumable stream of workspace-local Control Center events. */
+export declare class LiveEventsApiGroup extends LiveEventsApiGroup_base {
+}
+export {};
+//# sourceMappingURL=liveEvents.d.ts.map