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/server/persistence/repositories/delivery-graph/contract.d.ts ADDED Viewed

@@ -0,0 +1,2989 @@
+import * as Schema from "effect/Schema";
+export declare const EntityProjectionWrite: Schema.Struct<{
+    readonly projection: Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+        readonly projectionSchemaVersion: Schema.Int;
+        readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+        readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+        readonly displayKey: Schema.String;
+        readonly title: Schema.String;
+        readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+            readonly key: Schema.String;
+            readonly status: Schema.String;
+            readonly priority: Schema.NullOr<Schema.String>;
+            readonly estimatePoints: Schema.NullOr<Schema.Number>;
+            readonly summary: Schema.optionalKey<Schema.String>;
+            readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }>>>;
+            readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }>>>;
+            readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }>>>;
+            readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+            readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }, "Encoded">, never, never>>>;
+            readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+                readonly released: Schema.Boolean;
+                readonly releaseDate: Schema.NullOr<Schema.String>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+                readonly released: Schema.Boolean;
+                readonly releaseDate: Schema.NullOr<Schema.String>;
+            }, "Encoded">, never, never>>>;
+            readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly status: Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>;
+            }>>>;
+            readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly status: Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly status: Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>;
+            }, "Encoded">, never, never>>>;
+            readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourcePersonId: Schema.String;
+                readonly displayName: Schema.String;
+                readonly avatarUrl: Schema.NullOr<Schema.String>;
+                readonly active: Schema.Boolean;
+                readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourcePersonId: Schema.String;
+                readonly displayName: Schema.String;
+                readonly avatarUrl: Schema.NullOr<Schema.String>;
+                readonly active: Schema.Boolean;
+                readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+            }, "Encoded">, never, never>>>;
+            readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly body: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly updatedAt: Schema.NullOr<Schema.String>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly body: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly updatedAt: Schema.NullOr<Schema.String>;
+            }, "Encoded">, never, never>>>;
+            readonly commentTotal: Schema.optionalKey<Schema.Int>;
+            readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+            readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+            readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Encoded">, never, never>>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Encoded">, never, never>>;
+            }, "Encoded">, never, never>>>;
+            readonly historyTotal: Schema.optionalKey<Schema.Int>;
+            readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+            readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+        }>, Schema.TaggedStruct<"pull-request", {
+            readonly repository: Schema.String;
+            readonly sourceBranch: Schema.String;
+            readonly targetBranch: Schema.String;
+            readonly headRevision: Schema.String;
+            readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+        }>, Schema.TaggedStruct<"page", {
+            readonly spaceKey: Schema.String;
+            readonly revision: Schema.String;
+            readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+            readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+        }>, Schema.TaggedStruct<"pipeline-execution", {
+            readonly pipelineName: Schema.String;
+            readonly executionId: Schema.String;
+            readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+            readonly triggerRevision: Schema.String;
+        }>, Schema.TaggedStruct<"deployment", {
+            readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            readonly revision: Schema.String;
+            readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+        }>, Schema.TaggedStruct<"time-entry", {
+            readonly durationMinutes: Schema.Int;
+            readonly billable: Schema.Boolean;
+            readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+        }>]>;
+    }>;
+    readonly recordedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Bounded atomic set of immutable delivery-graph records. */
+export declare const DeliveryGraphWriteBatch: Schema.Struct<{
+    readonly entityProjections: Schema.$Array<Schema.Struct<{
+        readonly projection: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+            readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+            readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+            readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+            readonly projectionSchemaVersion: Schema.Int;
+            readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+            readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+            readonly displayKey: Schema.String;
+            readonly title: Schema.String;
+            readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                readonly key: Schema.String;
+                readonly status: Schema.String;
+                readonly priority: Schema.NullOr<Schema.String>;
+                readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                readonly summary: Schema.optionalKey<Schema.String>;
+                readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>>;
+                readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly key: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>>;
+                readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>>;
+                readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }, "Encoded">, never, never>>>;
+                readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                    readonly released: Schema.Boolean;
+                    readonly releaseDate: Schema.NullOr<Schema.String>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                    readonly released: Schema.Boolean;
+                    readonly releaseDate: Schema.NullOr<Schema.String>;
+                }, "Encoded">, never, never>>>;
+                readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly key: Schema.NullOr<Schema.String>;
+                    readonly summary: Schema.NullOr<Schema.String>;
+                    readonly status: Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>;
+                }>>>;
+                readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly key: Schema.NullOr<Schema.String>;
+                    readonly summary: Schema.NullOr<Schema.String>;
+                    readonly status: Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly key: Schema.NullOr<Schema.String>;
+                    readonly summary: Schema.NullOr<Schema.String>;
+                    readonly status: Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>;
+                }, "Encoded">, never, never>>>;
+                readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly sourcePersonId: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly avatarUrl: Schema.NullOr<Schema.String>;
+                    readonly active: Schema.Boolean;
+                    readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly sourcePersonId: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly avatarUrl: Schema.NullOr<Schema.String>;
+                    readonly active: Schema.Boolean;
+                    readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                }, "Encoded">, never, never>>>;
+                readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.String;
+                    readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                    readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                    readonly body: Schema.NullOr<Schema.String>;
+                    readonly createdAt: Schema.NullOr<Schema.String>;
+                    readonly updatedAt: Schema.NullOr<Schema.String>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.String;
+                    readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                    readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                    readonly body: Schema.NullOr<Schema.String>;
+                    readonly createdAt: Schema.NullOr<Schema.String>;
+                    readonly updatedAt: Schema.NullOr<Schema.String>;
+                }, "Encoded">, never, never>>>;
+                readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.String;
+                    readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                    readonly createdAt: Schema.NullOr<Schema.String>;
+                    readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly field: Schema.String;
+                        readonly from: Schema.NullOr<Schema.String>;
+                        readonly to: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly field: Schema.String;
+                        readonly from: Schema.NullOr<Schema.String>;
+                        readonly to: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly sourceId: Schema.String;
+                    readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                    readonly createdAt: Schema.NullOr<Schema.String>;
+                    readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly field: Schema.String;
+                        readonly from: Schema.NullOr<Schema.String>;
+                        readonly to: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly field: Schema.String;
+                        readonly from: Schema.NullOr<Schema.String>;
+                        readonly to: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>;
+                }, "Encoded">, never, never>>>;
+                readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+            }>, Schema.TaggedStruct<"pull-request", {
+                readonly repository: Schema.String;
+                readonly sourceBranch: Schema.String;
+                readonly targetBranch: Schema.String;
+                readonly headRevision: Schema.String;
+                readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+            }>, Schema.TaggedStruct<"page", {
+                readonly spaceKey: Schema.String;
+                readonly revision: Schema.String;
+                readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+            }>, Schema.TaggedStruct<"pipeline-execution", {
+                readonly pipelineName: Schema.String;
+                readonly executionId: Schema.String;
+                readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                readonly triggerRevision: Schema.String;
+            }>, Schema.TaggedStruct<"deployment", {
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly revision: Schema.String;
+                readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+            }>, Schema.TaggedStruct<"time-entry", {
+                readonly durationMinutes: Schema.Int;
+                readonly billable: Schema.Boolean;
+                readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+            }>]>;
+        }>;
+        readonly recordedAt: Schema.DateTimeUtcFromString;
+    }>>;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+        readonly endpointKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+        readonly resolution: Schema.TaggedUnion<{
+            readonly missing: Schema.TaggedStruct<"missing", {
+                readonly expectedKind: Schema.Literals<readonly ["entity", "release", "environment"]>;
+                readonly expectedEntityKind: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+                readonly missingKey: Schema.String;
+            }>;
+            readonly resolved: Schema.TaggedStruct<"resolved", {
+                readonly target: Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: Schema.TaggedStruct<"environment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly entity: Schema.TaggedStruct<"entity", {
+                        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly entityKind: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    }>;
+                }>;
+            }>;
+        }>;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+    }>>;
+    readonly evidenceItems: Schema.$Array<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+        readonly schemaVersion: Schema.Int;
+        readonly attribution: Schema.TaggedUnion<{
+            readonly plugin: Schema.TaggedStruct<"plugin", {
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+            }>;
+            readonly human: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly agent: Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>;
+            readonly system: Schema.TaggedStruct<"system", {
+                readonly component: Schema.String;
+            }>;
+        }>;
+        readonly verifier: Schema.TaggedUnion<{
+            readonly human: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly agent: Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>;
+            readonly system: Schema.TaggedStruct<"system", {
+                readonly component: Schema.String;
+            }>;
+        }>;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+        readonly recordedAt: Schema.DateTimeUtcFromString;
+        readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        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 retention: Schema.Struct<{
+            readonly classification: Schema.Literals<readonly ["audit", "evidence", "normalized-cache"]>;
+            readonly retainUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly legalHold: Schema.Boolean;
+        }>;
+    }>>;
+    readonly evidenceClaims: Schema.$Array<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly evidenceClaimId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">;
+        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+        readonly subjectNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+        readonly predicate: Schema.Literals<readonly ["relationship-observed", "status-observed", "approval-recorded", "check-observed", "execution-observed", "deployment-observed", "documentation-observed", "time-observed"]>;
+        readonly value: Schema.TaggedUnion<{
+            readonly revision: Schema.TaggedStruct<"revision", {
+                readonly value: Schema.String;
+            }>;
+            readonly state: Schema.TaggedStruct<"state", {
+                readonly value: Schema.String;
+            }>;
+            readonly reference: Schema.TaggedStruct<"reference", {
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            }>;
+            readonly flag: Schema.TaggedStruct<"flag", {
+                readonly value: Schema.Boolean;
+            }>;
+        }>;
+        readonly recordedAt: Schema.DateTimeUtcFromString;
+        readonly supersedesEvidenceClaimId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+    }>>;
+    readonly relationships: Schema.$Array<Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly relationshipSchemaVersion: Schema.Literal<1>;
+        readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+        readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+        readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+        readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+        readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+        readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+        readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+            readonly release: Schema.TaggedStruct<"release", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            }>;
+            readonly environment: Schema.TaggedStruct<"environment", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            }>;
+        }>>;
+        readonly lifecycle: Schema.TaggedUnion<{
+            readonly missing: Schema.TaggedStruct<"missing", {
+                readonly effectiveAt: Schema.DateTimeUtcFromString;
+                readonly reason: Schema.String;
+            }>;
+            readonly inferred: Schema.TaggedStruct<"inferred", {
+                readonly effectiveAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly proposed: Schema.TaggedStruct<"proposed", {
+                readonly effectiveAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly verified: Schema.TaggedStruct<"verified", {
+                readonly effectiveAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly governed: Schema.TaggedStruct<"governed", {
+                readonly effectiveAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly rejected: Schema.TaggedStruct<"rejected", {
+                readonly effectiveAt: Schema.DateTimeUtcFromString;
+                readonly reason: Schema.String;
+            }>;
+            readonly superseded: Schema.TaggedStruct<"superseded", {
+                readonly effectiveAt: Schema.DateTimeUtcFromString;
+                readonly reason: Schema.String;
+            }>;
+        }>;
+        readonly confidence: Schema.TaggedUnion<{
+            readonly unknown: Schema.TaggedStruct<"unknown", {
+                readonly rationale: Schema.String;
+            }>;
+            readonly inferred: Schema.TaggedStruct<"inferred", {
+                readonly score: Schema.Number;
+                readonly rationale: Schema.String;
+            }>;
+            readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+        }>;
+        readonly provenance: Schema.TaggedUnion<{
+            readonly plugin: Schema.TaggedStruct<"plugin", {
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+            }>;
+            readonly human: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                readonly rationale: Schema.String;
+            }>;
+            readonly agent: Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                readonly rationale: Schema.String;
+            }>;
+            readonly rule: Schema.TaggedStruct<"rule", {
+                readonly ruleId: Schema.String;
+                readonly ruleVersion: Schema.Int;
+                readonly rationale: Schema.String;
+            }>;
+        }>;
+        readonly recordedBy: Schema.TaggedUnion<{
+            readonly human: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly agent: Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>;
+            readonly system: Schema.TaggedStruct<"system", {
+                readonly component: Schema.String;
+            }>;
+        }>;
+        readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+        readonly recordedAt: Schema.DateTimeUtcFromString;
+    }>>;
+}>;
+/** Decoded atomic delivery-graph write batch. */
+export type DeliveryGraphWriteBatch = typeof DeliveryGraphWriteBatch.Type;
+/** Tagged, bounded read supported by the delivery-graph persistence seam. */
+export declare const DeliveryGraphQuery: Schema.TaggedUnion<{
+    readonly relationship: Schema.TaggedStruct<"relationship", {
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly revision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+    }>;
+    readonly evidence: Schema.TaggedStruct<"evidence", {
+        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+        readonly limit: Schema.Int;
+    }>;
+    readonly releaseSlice: Schema.TaggedStruct<"releaseSlice", {
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+        readonly limit: Schema.Int;
+    }>;
+    readonly workspaceEntityProjections: Schema.TaggedStruct<"workspaceEntityProjections", {
+        readonly owner: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">>;
+        readonly query: Schema.NullOr<Schema.String>;
+        readonly service: Schema.NullOr<Schema.Literals<readonly ["jira", "codecommit", "confluence", "codepipeline", "clockify"]>>;
+        readonly status: Schema.NullOr<Schema.Literals<readonly ["active", "done", "failed"]>>;
+        readonly type: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+        readonly limit: Schema.Int;
+    }>;
+    readonly relationshipHistory: Schema.TaggedStruct<"relationshipHistory", {
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly limit: Schema.Int;
+    }>;
+    readonly entityProjection: Schema.TaggedStruct<"entityProjection", {
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly revision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+    }>;
+    readonly node: Schema.TaggedStruct<"node", {
+        readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+    }>;
+    readonly entitySlice: Schema.TaggedStruct<"entitySlice", {
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly limit: Schema.Int;
+    }>;
+    readonly nodeRelationships: Schema.TaggedStruct<"nodeRelationships", {
+        readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+        readonly limit: Schema.Int;
+    }>;
+    readonly componentRelationships: Schema.TaggedStruct<"componentRelationships", {
+        readonly releaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+        readonly component: Schema.String;
+        readonly limit: Schema.Int;
+    }>;
+    readonly releaseSummary: Schema.TaggedStruct<"releaseSummary", {
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    }>;
+}>;
+/** Decoded delivery-graph read query. */
+export type DeliveryGraphQuery = typeof DeliveryGraphQuery.Type;
+export declare const PersistedEntityProjection: Schema.Struct<{
+    readonly projection: Schema.Struct<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+        readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+        readonly projectionSchemaVersion: Schema.Int;
+        readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+        readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+        readonly displayKey: Schema.String;
+        readonly title: Schema.String;
+        readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+            readonly key: Schema.String;
+            readonly status: Schema.String;
+            readonly priority: Schema.NullOr<Schema.String>;
+            readonly estimatePoints: Schema.NullOr<Schema.Number>;
+            readonly summary: Schema.optionalKey<Schema.String>;
+            readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }>>>;
+            readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }>>>;
+            readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }>>>;
+            readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+            readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+            }, "Encoded">, never, never>>>;
+            readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+                readonly released: Schema.Boolean;
+                readonly releaseDate: Schema.NullOr<Schema.String>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.NullOr<Schema.String>;
+                readonly released: Schema.Boolean;
+                readonly releaseDate: Schema.NullOr<Schema.String>;
+            }, "Encoded">, never, never>>>;
+            readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly status: Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>;
+            }>>>;
+            readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly status: Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.NullOr<Schema.String>;
+                readonly key: Schema.NullOr<Schema.String>;
+                readonly summary: Schema.NullOr<Schema.String>;
+                readonly status: Schema.NullOr<Schema.Struct<{
+                    readonly sourceId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.NullOr<Schema.String>;
+                }>>;
+            }, "Encoded">, never, never>>>;
+            readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourcePersonId: Schema.String;
+                readonly displayName: Schema.String;
+                readonly avatarUrl: Schema.NullOr<Schema.String>;
+                readonly active: Schema.Boolean;
+                readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourcePersonId: Schema.String;
+                readonly displayName: Schema.String;
+                readonly avatarUrl: Schema.NullOr<Schema.String>;
+                readonly active: Schema.Boolean;
+                readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+            }, "Encoded">, never, never>>>;
+            readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly body: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly updatedAt: Schema.NullOr<Schema.String>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly body: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly updatedAt: Schema.NullOr<Schema.String>;
+            }, "Encoded">, never, never>>>;
+            readonly commentTotal: Schema.optionalKey<Schema.Int>;
+            readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+            readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+            readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Encoded">, never, never>>;
+            }, "Type">, Schema.Struct.ReadonlySide<{
+                readonly sourceId: Schema.String;
+                readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                readonly createdAt: Schema.NullOr<Schema.String>;
+                readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Type">, Schema.Struct.ReadonlySide<{
+                    readonly field: Schema.String;
+                    readonly from: Schema.NullOr<Schema.String>;
+                    readonly to: Schema.NullOr<Schema.String>;
+                }, "Encoded">, never, never>>;
+            }, "Encoded">, never, never>>>;
+            readonly historyTotal: Schema.optionalKey<Schema.Int>;
+            readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+            readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+        }>, Schema.TaggedStruct<"pull-request", {
+            readonly repository: Schema.String;
+            readonly sourceBranch: Schema.String;
+            readonly targetBranch: Schema.String;
+            readonly headRevision: Schema.String;
+            readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+        }>, Schema.TaggedStruct<"page", {
+            readonly spaceKey: Schema.String;
+            readonly revision: Schema.String;
+            readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+            readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+        }>, Schema.TaggedStruct<"pipeline-execution", {
+            readonly pipelineName: Schema.String;
+            readonly executionId: Schema.String;
+            readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+            readonly triggerRevision: Schema.String;
+        }>, Schema.TaggedStruct<"deployment", {
+            readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            readonly revision: Schema.String;
+            readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+        }>, Schema.TaggedStruct<"time-entry", {
+            readonly durationMinutes: Schema.Int;
+            readonly billable: Schema.Boolean;
+            readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+        }>]>;
+    }>;
+    readonly recordedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Tagged read result; callers never need to understand the SQL representation. */
+export declare const DeliveryGraphReadResult: Schema.TaggedUnion<{
+    readonly relationship: Schema.TaggedStruct<"relationship", {
+        readonly value: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+            readonly relationshipSchemaVersion: Schema.Literal<1>;
+            readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+            readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+            readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+            readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly environment: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+            }>>;
+            readonly lifecycle: Schema.TaggedUnion<{
+                readonly missing: Schema.TaggedStruct<"missing", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly proposed: Schema.TaggedStruct<"proposed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly verified: Schema.TaggedStruct<"verified", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly governed: Schema.TaggedStruct<"governed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly rejected: Schema.TaggedStruct<"rejected", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly superseded: Schema.TaggedStruct<"superseded", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+            }>;
+            readonly confidence: Schema.TaggedUnion<{
+                readonly unknown: Schema.TaggedStruct<"unknown", {
+                    readonly rationale: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly score: Schema.Number;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+            }>;
+            readonly provenance: Schema.TaggedUnion<{
+                readonly plugin: Schema.TaggedStruct<"plugin", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                }>;
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly rule: Schema.TaggedStruct<"rule", {
+                    readonly ruleId: Schema.String;
+                    readonly ruleVersion: Schema.Int;
+                    readonly rationale: Schema.String;
+                }>;
+            }>;
+            readonly recordedBy: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.String;
+                }>;
+            }>;
+            readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            readonly recordedAt: Schema.DateTimeUtcFromString;
+        }>;
+    }>;
+    readonly evidence: Schema.TaggedStruct<"evidence", {
+        readonly value: Schema.Struct<{
+            readonly evidence: Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly schemaVersion: Schema.Int;
+                readonly attribution: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly verifier: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                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 retention: Schema.Struct<{
+                    readonly classification: Schema.Literals<readonly ["audit", "evidence", "normalized-cache"]>;
+                    readonly retainUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly legalHold: Schema.Boolean;
+                }>;
+            }>;
+            readonly claims: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceClaimId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly subjectNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly predicate: Schema.Literals<readonly ["relationship-observed", "status-observed", "approval-recorded", "check-observed", "execution-observed", "deployment-observed", "documentation-observed", "time-observed"]>;
+                readonly value: Schema.TaggedUnion<{
+                    readonly revision: Schema.TaggedStruct<"revision", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly state: Schema.TaggedStruct<"state", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly reference: Schema.TaggedStruct<"reference", {
+                        readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                    }>;
+                    readonly flag: Schema.TaggedStruct<"flag", {
+                        readonly value: Schema.Boolean;
+                    }>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly supersedesEvidenceClaimId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            }>>;
+        }>;
+    }>;
+    readonly releaseSlice: Schema.TaggedStruct<"releaseSlice", {
+        readonly value: Schema.Struct<{
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+            readonly truncated: Schema.Boolean;
+            readonly nodes: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly endpointKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly resolution: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly expectedKind: Schema.Literals<readonly ["entity", "release", "environment"]>;
+                        readonly expectedEntityKind: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+                        readonly missingKey: Schema.String;
+                    }>;
+                    readonly resolved: Schema.TaggedStruct<"resolved", {
+                        readonly target: Schema.TaggedUnion<{
+                            readonly release: Schema.TaggedStruct<"release", {
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly environment: Schema.TaggedStruct<"environment", {
+                                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly entity: Schema.TaggedStruct<"entity", {
+                                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                                readonly entityKind: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly createdAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly entityProjections: Schema.$Array<Schema.Struct<{
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: Schema.TaggedStruct<"environment", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    }>;
+                }>>;
+                readonly lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly evidenceClaims: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceClaimId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly subjectNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly predicate: Schema.Literals<readonly ["relationship-observed", "status-observed", "approval-recorded", "check-observed", "execution-observed", "deployment-observed", "documentation-observed", "time-observed"]>;
+                readonly value: Schema.TaggedUnion<{
+                    readonly revision: Schema.TaggedStruct<"revision", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly state: Schema.TaggedStruct<"state", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly reference: Schema.TaggedStruct<"reference", {
+                        readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                    }>;
+                    readonly flag: Schema.TaggedStruct<"flag", {
+                        readonly value: Schema.Boolean;
+                    }>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly supersedesEvidenceClaimId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            }>>;
+            readonly evidenceItems: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly schemaVersion: Schema.Int;
+                readonly attribution: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly verifier: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                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 retention: Schema.Struct<{
+                    readonly classification: Schema.Literals<readonly ["audit", "evidence", "normalized-cache"]>;
+                    readonly retainUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly legalHold: Schema.Boolean;
+                }>;
+            }>>;
+        }>;
+    }>;
+    readonly workspaceEntityProjections: Schema.TaggedStruct<"workspaceEntityProjections", {
+        readonly value: Schema.Struct<{
+            readonly matchedCount: Schema.Int;
+            readonly ownerOptions: Schema.$Array<Schema.Struct<{
+                readonly avatarFallback: Schema.String;
+                readonly displayName: Schema.String;
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                readonly roles: Schema.$Array<Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>>;
+            }>>;
+            readonly ownerOptionsTruncated: Schema.Boolean;
+            readonly totalCount: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly items: Schema.$Array<Schema.Struct<{
+                readonly canonicalReleaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly owners: Schema.$Array<Schema.Struct<{
+                    readonly avatarFallback: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly roles: Schema.$Array<Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>>;
+                }>>;
+                readonly ownersTruncated: Schema.Boolean;
+                readonly releaseIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly releaseMembershipsTruncated: Schema.Boolean;
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+        }>;
+    }>;
+    readonly relationshipHistory: Schema.TaggedStruct<"relationshipHistory", {
+        readonly value: Schema.$Array<Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+            readonly relationshipSchemaVersion: Schema.Literal<1>;
+            readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+            readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+            readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+            readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly environment: Schema.TaggedStruct<"environment", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                }>;
+            }>>;
+            readonly lifecycle: Schema.TaggedUnion<{
+                readonly missing: Schema.TaggedStruct<"missing", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly proposed: Schema.TaggedStruct<"proposed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly verified: Schema.TaggedStruct<"verified", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly governed: Schema.TaggedStruct<"governed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly rejected: Schema.TaggedStruct<"rejected", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly superseded: Schema.TaggedStruct<"superseded", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+            }>;
+            readonly confidence: Schema.TaggedUnion<{
+                readonly unknown: Schema.TaggedStruct<"unknown", {
+                    readonly rationale: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly score: Schema.Number;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+            }>;
+            readonly provenance: Schema.TaggedUnion<{
+                readonly plugin: Schema.TaggedStruct<"plugin", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                }>;
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly rule: Schema.TaggedStruct<"rule", {
+                    readonly ruleId: Schema.String;
+                    readonly ruleVersion: Schema.Int;
+                    readonly rationale: Schema.String;
+                }>;
+            }>;
+            readonly recordedBy: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.String;
+                }>;
+            }>;
+            readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            readonly recordedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }>;
+    readonly entityProjection: Schema.TaggedStruct<"entityProjection", {
+        readonly value: Schema.Struct<{
+            readonly projection: Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly projectionSchemaVersion: Schema.Int;
+                readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                readonly displayKey: Schema.String;
+                readonly title: Schema.String;
+                readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                    readonly key: Schema.String;
+                    readonly status: Schema.String;
+                    readonly priority: Schema.NullOr<Schema.String>;
+                    readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                    readonly summary: Schema.optionalKey<Schema.String>;
+                    readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>>;
+                    readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>>;
+                    readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>>;
+                    readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                    readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>>;
+                    readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                        readonly released: Schema.Boolean;
+                        readonly releaseDate: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                        readonly released: Schema.Boolean;
+                        readonly releaseDate: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>>;
+                    readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly summary: Schema.NullOr<Schema.String>;
+                        readonly status: Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>;
+                    }>>>;
+                    readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly summary: Schema.NullOr<Schema.String>;
+                        readonly status: Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly summary: Schema.NullOr<Schema.String>;
+                        readonly status: Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>;
+                    }, "Encoded">, never, never>>>;
+                    readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourcePersonId: Schema.String;
+                        readonly displayName: Schema.String;
+                        readonly avatarUrl: Schema.NullOr<Schema.String>;
+                        readonly active: Schema.Boolean;
+                        readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourcePersonId: Schema.String;
+                        readonly displayName: Schema.String;
+                        readonly avatarUrl: Schema.NullOr<Schema.String>;
+                        readonly active: Schema.Boolean;
+                        readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                    }, "Encoded">, never, never>>>;
+                    readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly body: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly updatedAt: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly body: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly updatedAt: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>>;
+                    readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                    readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                    readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                    readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>;
+                    }, "Encoded">, never, never>>>;
+                    readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                    readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                    readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                }>, Schema.TaggedStruct<"pull-request", {
+                    readonly repository: Schema.String;
+                    readonly sourceBranch: Schema.String;
+                    readonly targetBranch: Schema.String;
+                    readonly headRevision: Schema.String;
+                    readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                }>, Schema.TaggedStruct<"page", {
+                    readonly spaceKey: Schema.String;
+                    readonly revision: Schema.String;
+                    readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                    readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                    readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                }>, Schema.TaggedStruct<"pipeline-execution", {
+                    readonly pipelineName: Schema.String;
+                    readonly executionId: Schema.String;
+                    readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                    readonly triggerRevision: Schema.String;
+                }>, Schema.TaggedStruct<"deployment", {
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    readonly revision: Schema.String;
+                    readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                }>, Schema.TaggedStruct<"time-entry", {
+                    readonly durationMinutes: Schema.Int;
+                    readonly billable: Schema.Boolean;
+                    readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                }>]>;
+            }>;
+            readonly recordedAt: Schema.DateTimeUtcFromString;
+        }>;
+    }>;
+    readonly node: Schema.TaggedStruct<"node", {
+        readonly value: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly endpointKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly resolution: Schema.TaggedUnion<{
+                readonly missing: Schema.TaggedStruct<"missing", {
+                    readonly expectedKind: Schema.Literals<readonly ["entity", "release", "environment"]>;
+                    readonly expectedEntityKind: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+                    readonly missingKey: Schema.String;
+                }>;
+                readonly resolved: Schema.TaggedStruct<"resolved", {
+                    readonly target: Schema.TaggedUnion<{
+                        readonly release: Schema.TaggedStruct<"release", {
+                            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        }>;
+                        readonly environment: Schema.TaggedStruct<"environment", {
+                            readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        }>;
+                        readonly entity: Schema.TaggedStruct<"entity", {
+                            readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                            readonly entityKind: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+            readonly createdAt: Schema.DateTimeUtcFromString;
+        }>;
+    }>;
+    readonly entitySlice: Schema.TaggedStruct<"entitySlice", {
+        readonly value: Schema.Struct<{
+            readonly entity: Schema.Struct<{
+                readonly canonicalReleaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly owners: Schema.$Array<Schema.Struct<{
+                    readonly avatarFallback: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly roles: Schema.$Array<Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>>;
+                }>>;
+                readonly ownersTruncated: Schema.Boolean;
+                readonly releaseIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly releaseMembershipsTruncated: Schema.Boolean;
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly truncated: Schema.Boolean;
+            readonly nodes: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly endpointKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly resolution: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly expectedKind: Schema.Literals<readonly ["entity", "release", "environment"]>;
+                        readonly expectedEntityKind: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+                        readonly missingKey: Schema.String;
+                    }>;
+                    readonly resolved: Schema.TaggedStruct<"resolved", {
+                        readonly target: Schema.TaggedUnion<{
+                            readonly release: Schema.TaggedStruct<"release", {
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly environment: Schema.TaggedStruct<"environment", {
+                                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly entity: Schema.TaggedStruct<"entity", {
+                                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                                readonly entityKind: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly createdAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relatedEntityProjections: Schema.$Array<Schema.Struct<{
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: Schema.TaggedStruct<"environment", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    }>;
+                }>>;
+                readonly lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly evidenceClaims: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceClaimId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly subjectNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly predicate: Schema.Literals<readonly ["relationship-observed", "status-observed", "approval-recorded", "check-observed", "execution-observed", "deployment-observed", "documentation-observed", "time-observed"]>;
+                readonly value: Schema.TaggedUnion<{
+                    readonly revision: Schema.TaggedStruct<"revision", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly state: Schema.TaggedStruct<"state", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly reference: Schema.TaggedStruct<"reference", {
+                        readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                    }>;
+                    readonly flag: Schema.TaggedStruct<"flag", {
+                        readonly value: Schema.Boolean;
+                    }>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly supersedesEvidenceClaimId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            }>>;
+            readonly evidenceItems: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly schemaVersion: Schema.Int;
+                readonly attribution: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly verifier: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                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 retention: Schema.Struct<{
+                    readonly classification: Schema.Literals<readonly ["audit", "evidence", "normalized-cache"]>;
+                    readonly retainUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly legalHold: Schema.Boolean;
+                }>;
+            }>>;
+        }>;
+    }>;
+    readonly nodeRelationships: Schema.TaggedStruct<"nodeRelationships", {
+        readonly value: Schema.Struct<{
+            readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly truncated: Schema.Boolean;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: Schema.TaggedStruct<"environment", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    }>;
+                }>>;
+                readonly lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+        }>;
+    }>;
+    readonly componentRelationships: Schema.TaggedStruct<"componentRelationships", {
+        readonly value: Schema.Struct<{
+            readonly releaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly truncated: Schema.Boolean;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: Schema.TaggedStruct<"environment", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    }>;
+                }>>;
+                readonly lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+        }>;
+    }>;
+    readonly releaseSummary: Schema.TaggedStruct<"releaseSummary", {
+        readonly value: Schema.Struct<{
+            readonly issues: Schema.Int;
+            readonly pullRequests: Schema.Int;
+            readonly pipelineExecutions: Schema.Int;
+        }>;
+    }>;
+}>;
+/** Decoded delivery-graph read result. */
+export type DeliveryGraphReadResult = typeof DeliveryGraphReadResult.Type;
+/** Counts committed by one atomic delivery-graph write. */
+export declare const DeliveryGraphWriteReceipt: Schema.Struct<{
+    readonly entityProjectionCount: Schema.Int;
+    readonly nodeCount: Schema.Int;
+    readonly evidenceItemCount: Schema.Int;
+    readonly evidenceClaimCount: Schema.Int;
+    readonly relationshipCount: Schema.Int;
+}>;
+/** Decoded delivery-graph write receipt. */
+export type DeliveryGraphWriteReceipt = typeof DeliveryGraphWriteReceipt.Type;
+declare const DeliveryGraphInputError_base: Schema.Class<DeliveryGraphInputError, Schema.TaggedStruct<"DeliveryGraphInputError", {
+    readonly operation: Schema.Literals<readonly ["read", "write"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Invalid unknown input rejected before any graph SQL is run. */
+export declare class DeliveryGraphInputError extends DeliveryGraphInputError_base {
+}
+export {};
+//# sourceMappingURL=contract.d.ts.map