@knpkv/control-center 0.1.0

package/dist/server/server/persistence/repositories/peopleRepository.d.ts

@@ -0,0 +1,407 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Database } from "../Database.js";
+import { PersistedRecordError, PersistenceOperationError, RecordNotFoundError } from "../errors.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+declare const makePeopleRepository: Effect.Effect<{
+    createPerson: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, person: Schema.Struct.ReadonlySide<{
+        readonly avatar: Schema.TaggedUnion<{
+            readonly initials: Schema.TaggedStruct<"initials", {
+                readonly text: Schema.String;
+            }>;
+            readonly reference: Schema.TaggedStruct<"reference", {
+                readonly reference: Schema.String;
+            }>;
+        }>;
+        readonly displayName: Schema.String;
+        readonly isActive: Schema.Boolean;
+        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly sourceIdentities: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+        }>>;
+    }, "Type">, createdAt: DateTime.Utc) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly person: Schema.Struct<{
+            readonly avatar: Schema.TaggedUnion<{
+                readonly initials: Schema.TaggedStruct<"initials", {
+                    readonly text: Schema.String;
+                }>;
+                readonly reference: Schema.TaggedStruct<"reference", {
+                    readonly reference: Schema.String;
+                }>;
+            }>;
+            readonly displayName: Schema.String;
+            readonly isActive: Schema.Boolean;
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            readonly sourceIdentities: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, Schema.SchemaError | RecordNotFoundError | import("../errors.js").RecordAlreadyExistsError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    getPerson: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, personId: string & import("effect/Brand").Brand<"PersonId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly person: Schema.Struct<{
+            readonly avatar: Schema.TaggedUnion<{
+                readonly initials: Schema.TaggedStruct<"initials", {
+                    readonly text: Schema.String;
+                }>;
+                readonly reference: Schema.TaggedStruct<"reference", {
+                    readonly reference: Schema.String;
+                }>;
+            }>;
+            readonly displayName: Schema.String;
+            readonly isActive: Schema.Boolean;
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            readonly sourceIdentities: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    findPersonBySourceIdentity: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, identity: Schema.Struct.ReadonlySide<{
+        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+    }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly person: Schema.Struct<{
+            readonly avatar: Schema.TaggedUnion<{
+                readonly initials: Schema.TaggedStruct<"initials", {
+                    readonly text: Schema.String;
+                }>;
+                readonly reference: Schema.TaggedStruct<"reference", {
+                    readonly reference: Schema.String;
+                }>;
+            }>;
+            readonly displayName: Schema.String;
+            readonly isActive: Schema.Boolean;
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            readonly sourceIdentities: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    updatePerson: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, person: Schema.Struct.ReadonlySide<{
+        readonly avatar: Schema.TaggedUnion<{
+            readonly initials: Schema.TaggedStruct<"initials", {
+                readonly text: Schema.String;
+            }>;
+            readonly reference: Schema.TaggedStruct<"reference", {
+                readonly reference: Schema.String;
+            }>;
+        }>;
+        readonly displayName: Schema.String;
+        readonly isActive: Schema.Boolean;
+        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly sourceIdentities: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+        }>>;
+    }, "Type">, expectedRevision: number & import("effect/Brand").Brand<"RecordRevision">, updatedAt: DateTime.Utc) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly person: Schema.Struct<{
+            readonly avatar: Schema.TaggedUnion<{
+                readonly initials: Schema.TaggedStruct<"initials", {
+                    readonly text: Schema.String;
+                }>;
+                readonly reference: Schema.TaggedStruct<"reference", {
+                    readonly reference: Schema.String;
+                }>;
+            }>;
+            readonly displayName: Schema.String;
+            readonly isActive: Schema.Boolean;
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            readonly sourceIdentities: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, unknown, never>;
+    createRoleAssignment: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, assignment: Schema.Struct.ReadonlySide<{
+        readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        }>, Schema.TaggedStruct<"agent", {
+            readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+        }>]>;
+        readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+        readonly lifecycle: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"active", {
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"ended">;
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+            readonly endedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"revoked">;
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+            readonly revokedAt: Schema.DateTimeUtcFromString;
+        }>]>;
+        readonly role: 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 scope: Schema.TaggedUnion<{
+            readonly release: Schema.TaggedStruct<"release", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            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 workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            readonly entity: Schema.TaggedStruct<"entity", {
+                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            readonly workspace: Schema.TaggedStruct<"workspace", {
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+        }>;
+    }, "Type">, createdAt: DateTime.Utc) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly assignment: Schema.Struct<{
+            readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>, Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>]>;
+            readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+            readonly lifecycle: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"active", {
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"ended">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly endedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"revoked">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly revokedAt: Schema.DateTimeUtcFromString;
+            }>]>;
+            readonly role: 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 scope: Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                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 workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly entity: Schema.TaggedStruct<"entity", {
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly workspace: Schema.TaggedStruct<"workspace", {
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+            }>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | import("../errors.js").RecordAlreadyExistsError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    getRoleAssignment: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, assignmentId: string & import("effect/Brand").Brand<"RoleAssignmentId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly assignment: Schema.Struct<{
+            readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>, Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>]>;
+            readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+            readonly lifecycle: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"active", {
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"ended">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly endedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"revoked">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly revokedAt: Schema.DateTimeUtcFromString;
+            }>]>;
+            readonly role: 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 scope: Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                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 workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly entity: Schema.TaggedStruct<"entity", {
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly workspace: Schema.TaggedStruct<"workspace", {
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+            }>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    listRoleAssignments: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly assignment: Schema.Struct<{
+            readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>, Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>]>;
+            readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+            readonly lifecycle: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"active", {
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"ended">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly endedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"revoked">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly revokedAt: Schema.DateTimeUtcFromString;
+            }>]>;
+            readonly role: 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 scope: Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                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 workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly entity: Schema.TaggedStruct<"entity", {
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly workspace: Schema.TaggedStruct<"workspace", {
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+            }>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">[], PersistenceOperationError | import("../errors.js").QuarantineWriteError, never>;
+    updateRoleAssignment: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, assignment: Schema.Struct.ReadonlySide<{
+        readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        }>, Schema.TaggedStruct<"agent", {
+            readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+        }>]>;
+        readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+        readonly lifecycle: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"active", {
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"ended">;
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+            readonly endedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"revoked">;
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+            readonly revokedAt: Schema.DateTimeUtcFromString;
+        }>]>;
+        readonly role: 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 scope: Schema.TaggedUnion<{
+            readonly release: Schema.TaggedStruct<"release", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            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 workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            readonly entity: Schema.TaggedStruct<"entity", {
+                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            readonly workspace: Schema.TaggedStruct<"workspace", {
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+        }>;
+    }, "Type">, expectedRevision: number & import("effect/Brand").Brand<"RecordRevision">, updatedAt: DateTime.Utc) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly assignment: Schema.Struct<{
+            readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>, Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>]>;
+            readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+            readonly lifecycle: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"active", {
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"ended">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly endedAt: Schema.DateTimeUtcFromString;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.tag<"revoked">;
+                readonly assignedAt: Schema.DateTimeUtcFromString;
+                readonly revokedAt: Schema.DateTimeUtcFromString;
+            }>]>;
+            readonly role: 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 scope: Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                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 workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly entity: Schema.TaggedStruct<"entity", {
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+                readonly workspace: Schema.TaggedStruct<"workspace", {
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                }>;
+            }>;
+        }>;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, unknown, never>;
+}, never, Crypto.Crypto | Database | QuarantineRepository>;
+/** Workspace-scoped canonical people, identities, and collaborator roles. */
+export interface PeopleRepositoryService extends Success<typeof makePeopleRepository> {
+}
+declare const PeopleRepository_base: Context.ServiceClass<PeopleRepository, "@knpkv/control-center/PeopleRepository", PeopleRepositoryService>;
+/** Effect service for human-centric collaborator persistence. */
+export declare class PeopleRepository extends PeopleRepository_base {
+    /** Layer that binds SQL queries to the shared database at construction. */
+    static readonly layer: Layer.Layer<PeopleRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+export {};
+//# sourceMappingURL=peopleRepository.d.ts.map

package/dist/server/server/persistence/repositories/peopleRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peopleRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/peopleRepository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAcvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAUnG,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAyGhE,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAwiBxB,CAAA;AAEF,6EAA6E;AAC7E,MAAM,WAAW,uBAAwB,SAAQ,OAAO,CAAC,OAAO,oBAAoB,CAAC;CAAG;;AAExF,iEAAiE;AACjE,qBAAa,gBAAiB,SAAQ,qBAErC;IACC,2EAA2E;IAC3E,MAAM,CAAC,QAAQ,CAAC,KAAK,wFAAuD;CAC7E"}

package/dist/server/server/persistence/repositories/persistedRowQuarantine.d.ts

@@ -0,0 +1,20 @@
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { WorkspaceId } from "../../../domain/identifiers.js";
+import type { UtcTimestamp } from "../../../domain/utcTimestamp.js";
+import { PersistenceOperationError } from "../errors.js";
+import type { QuarantineDiagnosticSummary, QuarantinedRecordMetadata, QuarantineReasonCode, QuarantineRecordKind } from "./models.js";
+import type { QuarantineRepositoryService } from "./quarantineRepository.js";
+/** Fixed, redacted identity for quarantining one malformed persisted row. */
+export interface PersistedRowDiagnostic {
+    readonly workspaceId: WorkspaceId;
+    readonly recordKind: QuarantineRecordKind;
+    readonly recordKey: QuarantinedRecordMetadata["recordKey"];
+    readonly diagnosticCode: QuarantineReasonCode;
+    readonly diagnosticSummary: QuarantineDiagnosticSummary;
+    readonly observedAt: UtcTimestamp;
+    readonly row: unknown;
+}
+/** Build row-level quarantine writes without retaining any malformed values. */
+export declare const makePersistedRowQuarantine: (cryptoService: Crypto.Crypto, quarantine: QuarantineRepositoryService) => (diagnostic: PersistedRowDiagnostic) => Effect.Effect<void, PersistenceOperationError | import("../errors.js").QuarantineWriteError, never>;
+//# sourceMappingURL=persistedRowQuarantine.d.ts.map

package/dist/server/server/persistence/repositories/persistedRowQuarantine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistedRowQuarantine.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/persistedRowQuarantine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AACnE,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AAExD,OAAO,KAAK,EACV,2BAA2B,EAC3B,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAA;AAE5E,6EAA6E;AAC7E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAA;IACzC,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC,WAAW,CAAC,CAAA;IAC1D,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAA;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,2BAA2B,CAAA;IACvD,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CACtB;AAED,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,GACrC,eAAe,MAAM,CAAC,MAAM,EAC5B,YAAY,2BAA2B,gJA8BxC,CAAA"}

package/dist/server/server/persistence/repositories/pluginConfigurationModels.d.ts

@@ -0,0 +1,76 @@
+import * as Schema from "effect/Schema";
+/** Stable field key from a negotiated plugin descriptor. */
+export declare const StoredPluginConfigurationKey: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+export type StoredPluginConfigurationKey = typeof StoredPluginConfigurationKey.Type;
+/** Durable non-secret value or opaque secret reference for one plugin field. */
+export declare const StoredPluginConfigurationValue: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"text", {
+    readonly value: Schema.String;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"url", {
+    readonly value: Schema.String;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"boolean", {
+    readonly value: Schema.Boolean;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"integer", {
+    readonly value: Schema.Int;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"select", {
+    readonly value: Schema.String;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"secret-reference", {
+    readonly ref: Schema.brand<Schema.String, "SecretRef">;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>]>;
+export type StoredPluginConfigurationValue = typeof StoredPluginConfigurationValue.Type;
+/** Canonical ordered plugin configuration persisted as bounded JSON. */
+export declare const StoredPluginConfiguration: Schema.$Array<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"text", {
+    readonly value: Schema.String;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"url", {
+    readonly value: Schema.String;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"boolean", {
+    readonly value: Schema.Boolean;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"integer", {
+    readonly value: Schema.Int;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"select", {
+    readonly value: Schema.String;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>, Schema.TaggedStruct<"secret-reference", {
+    readonly ref: Schema.brand<Schema.String, "SecretRef">;
+    readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+}>]>>;
+export type StoredPluginConfiguration = typeof StoredPluginConfiguration.Type;
+/** Revisioned secret-safe configuration record. */
+export declare const PluginConfigurationRecord: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly revision: Schema.Int;
+    readonly values: Schema.$Array<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"text", {
+        readonly value: Schema.String;
+        readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+    }>, Schema.TaggedStruct<"url", {
+        readonly value: Schema.String;
+        readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+    }>, Schema.TaggedStruct<"boolean", {
+        readonly value: Schema.Boolean;
+        readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+    }>, Schema.TaggedStruct<"integer", {
+        readonly value: Schema.Int;
+        readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+    }>, Schema.TaggedStruct<"select", {
+        readonly value: Schema.String;
+        readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+    }>, Schema.TaggedStruct<"secret-reference", {
+        readonly ref: Schema.brand<Schema.String, "SecretRef">;
+        readonly key: Schema.brand<Schema.String, "StoredPluginConfigurationKey">;
+    }>]>>;
+    readonly configurationDigest: Schema.brand<Schema.String, "BlobDigest">;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly updatedAt: Schema.DateTimeUtcFromString;
+}>;
+export type PluginConfigurationRecord = typeof PluginConfigurationRecord.Type;
+//# sourceMappingURL=pluginConfigurationModels.d.ts.map

package/dist/server/server/persistence/repositories/pluginConfigurationModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluginConfigurationModels.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/pluginConfigurationModels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAQvC,4DAA4D;AAC5D,eAAO,MAAM,4BAA4B,6DAIW,CAAA;AAEpD,MAAM,MAAM,4BAA4B,GAAG,OAAO,4BAA4B,CAAC,IAAI,CAAA;AAKnF,gFAAgF;AAChF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;IAON,CAAA;AAErC,MAAM,MAAM,8BAA8B,GAAG,OAAO,8BAA8B,CAAC,IAAI,CAAA;AAEvF,wEAAwE;AACxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;KAiBrC,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA;AAE7E,mDAAmD;AACnD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;EAQpC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA"}