@knpkv/control-center 0.1.0

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

@@ -0,0 +1,431 @@
+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, SourceIdentityMismatchError } from "../errors.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+declare const makePluginRuntimeRepository: Effect.Effect<{
+    acceptPluginDescriptor: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify", rawDescriptor: unknown, expectedRevision: number, observedAt: DateTime.Utc) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly revision: Schema.Int;
+        readonly descriptorGeneration: Schema.Int;
+        readonly descriptorSchemaVersion: Schema.Int;
+        readonly descriptorJson: Schema.String;
+        readonly descriptorDigest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly acceptedAt: Schema.DateTimeUtcFromString;
+        readonly health: 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 consecutiveFailures: Schema.Int;
+    }, "Type">, unknown, never>;
+    beginSyncAttempt: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify", streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">, startedAt: DateTime.Utc) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly attemptSequence: Schema.Int;
+        readonly startedRevision: Schema.Int;
+        readonly startedAt: Schema.DateTimeUtcFromString;
+        readonly outcome: Schema.NullOr<Schema.Literals<readonly ["synchronized", "source-unavailable", "interrupted"]>>;
+        readonly endingRevision: Schema.NullOr<Schema.Int>;
+        readonly pagesCommitted: Schema.NullOr<Schema.Int>;
+        readonly completedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, RecordNotFoundError | SourceIdentityMismatchError | PersistenceOperationError, never>;
+    claimSync: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify", streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">, claimId: string, claimedAt: DateTime.Utc, expiresAt: DateTime.Utc) => Effect.Effect<boolean, unknown, never>;
+    commitNormalizedPage: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify", streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">, expectedRevision: number, page: Schema.Struct.ReadonlySide<{
+        readonly events: Schema.$Array<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"UpsertEntity", {
+            readonly sourceUrl: Schema.NullOr<Schema.decodeTo<Schema.URL, Schema.String, never, never>>;
+            readonly title: Schema.String;
+            readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly entityType: Schema.brand<Schema.String, string>;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"TombstoneEntity", {
+            readonly reason: Schema.String;
+            readonly entityType: Schema.brand<Schema.String, string>;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"AppendEvidence", {
+            readonly evidenceId: Schema.brand<Schema.String, string>;
+            readonly subject: Schema.Struct<{
+                entityType: Schema.brand<Schema.String, string>;
+                vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>;
+            readonly evidenceType: Schema.brand<Schema.String, string>;
+            readonly summary: Schema.String;
+            readonly capturedAt: Schema.DateTimeUtcFromString;
+            readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"UpsertPerson", {
+            readonly vendorPersonId: Schema.brand<Schema.String, string>;
+            readonly displayName: Schema.String;
+            readonly avatarUrl: Schema.NullOr<Schema.decodeTo<Schema.URL, Schema.String, never, never>>;
+            readonly active: Schema.Boolean;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"ProposeRelationship", {
+            readonly relationshipId: Schema.brand<Schema.String, string>;
+            readonly from: Schema.Struct<{
+                entityType: Schema.brand<Schema.String, string>;
+                vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>;
+            readonly to: Schema.Struct<{
+                entityType: Schema.brand<Schema.String, string>;
+                vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>;
+            readonly relationshipType: Schema.brand<Schema.String, string>;
+            readonly confidence: Schema.Number;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>]>>;
+        readonly checkpointAfterPage: Schema.brand<Schema.String, string>;
+        readonly hasMore: Schema.Boolean;
+    }, "Type">, committedAt: DateTime.Utc, successfulHealth: Schema.Struct.ReadonlySide<{
+        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;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        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;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"healthy">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"disabled">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly revision: Schema.Int;
+        readonly checkpointJson: Schema.NullOr<Schema.String>;
+        readonly checkpointDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+        readonly lastPageId: Schema.NullOr<Schema.brand<Schema.String, "PluginPageId">>;
+        readonly synchronizedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, unknown, never>;
+    commitNormalizedPageReceipt: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify", streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">, expectedRevision: number, page: Schema.Struct.ReadonlySide<{
+        readonly events: Schema.$Array<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"UpsertEntity", {
+            readonly sourceUrl: Schema.NullOr<Schema.decodeTo<Schema.URL, Schema.String, never, never>>;
+            readonly title: Schema.String;
+            readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly entityType: Schema.brand<Schema.String, string>;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"TombstoneEntity", {
+            readonly reason: Schema.String;
+            readonly entityType: Schema.brand<Schema.String, string>;
+            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"AppendEvidence", {
+            readonly evidenceId: Schema.brand<Schema.String, string>;
+            readonly subject: Schema.Struct<{
+                entityType: Schema.brand<Schema.String, string>;
+                vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>;
+            readonly evidenceType: Schema.brand<Schema.String, string>;
+            readonly summary: Schema.String;
+            readonly capturedAt: Schema.DateTimeUtcFromString;
+            readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"UpsertPerson", {
+            readonly vendorPersonId: Schema.brand<Schema.String, string>;
+            readonly displayName: Schema.String;
+            readonly avatarUrl: Schema.NullOr<Schema.decodeTo<Schema.URL, Schema.String, never, never>>;
+            readonly active: Schema.Boolean;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>, Schema.TaggedStruct<"ProposeRelationship", {
+            readonly relationshipId: Schema.brand<Schema.String, string>;
+            readonly from: Schema.Struct<{
+                entityType: Schema.brand<Schema.String, string>;
+                vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>;
+            readonly to: Schema.Struct<{
+                entityType: Schema.brand<Schema.String, string>;
+                vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+            }>;
+            readonly relationshipType: Schema.brand<Schema.String, string>;
+            readonly confidence: Schema.Number;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+            readonly eventId: Schema.brand<Schema.String, string>;
+            readonly observedAt: Schema.DateTimeUtcFromString;
+            readonly revision: Schema.brand<Schema.String, "Revision">;
+        }>]>>;
+        readonly checkpointAfterPage: Schema.brand<Schema.String, string>;
+        readonly hasMore: Schema.Boolean;
+    }, "Type">, committedAt: DateTime.Utc, successfulHealth: Schema.Struct.ReadonlySide<{
+        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;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        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;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"healthy">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"disabled">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<{
+        acceptedEventIds: string[];
+        pageCommitted: boolean;
+        stream: Schema.Struct.ReadonlySide<{
+            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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+            readonly revision: Schema.Int;
+            readonly checkpointJson: Schema.NullOr<Schema.String>;
+            readonly checkpointDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+            readonly lastPageId: Schema.NullOr<Schema.brand<Schema.String, "PluginPageId">>;
+            readonly synchronizedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        }, "Type">;
+    }, unknown, never>;
+    commitPage: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly revision: Schema.Int;
+        readonly checkpointJson: Schema.NullOr<Schema.String>;
+        readonly checkpointDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+        readonly lastPageId: Schema.NullOr<Schema.brand<Schema.String, "PluginPageId">>;
+        readonly synchronizedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, unknown, never>;
+    completeSyncAttempt: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">, attemptSequence: number, outcome: "source-unavailable" | "synchronized", completedAt: DateTime.Utc) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly attemptSequence: Schema.Int;
+        readonly startedRevision: Schema.Int;
+        readonly startedAt: Schema.DateTimeUtcFromString;
+        readonly outcome: Schema.NullOr<Schema.Literals<readonly ["synchronized", "source-unavailable", "interrupted"]>>;
+        readonly endingRevision: Schema.NullOr<Schema.Int>;
+        readonly pagesCommitted: Schema.NullOr<Schema.Int>;
+        readonly completedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, RecordNotFoundError | SourceIdentityMismatchError | PersistenceOperationError, never>;
+    getCache: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly recordKey: Schema.brand<Schema.String, "PluginRecordKey">;
+        readonly state: Schema.Literals<readonly ["present", "tombstoned"]>;
+        readonly payloadJson: Schema.NullOr<Schema.String>;
+        readonly payloadDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+        readonly sourceRevision: Schema.brand<Schema.String, "Revision">;
+        readonly lastPageId: Schema.brand<Schema.String, "PluginPageId">;
+        readonly cachedAt: Schema.DateTimeUtcFromString;
+        readonly tombstonedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">[], PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    getLastSuccessfulHealth: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"healthy">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }, "Type"> | null, PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    getRuntime: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly revision: Schema.Int;
+        readonly descriptorGeneration: Schema.Int;
+        readonly descriptorSchemaVersion: Schema.Int;
+        readonly descriptorJson: Schema.String;
+        readonly descriptorDigest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly acceptedAt: Schema.DateTimeUtcFromString;
+        readonly health: 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 consecutiveFailures: Schema.Int;
+    }, "Type">, RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    getSyncAttemptState: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly latestAttempt: Schema.NullOr<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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+            readonly attemptSequence: Schema.Int;
+            readonly startedRevision: Schema.Int;
+            readonly startedAt: Schema.DateTimeUtcFromString;
+            readonly outcome: Schema.NullOr<Schema.Literals<readonly ["synchronized", "source-unavailable", "interrupted"]>>;
+            readonly endingRevision: Schema.NullOr<Schema.Int>;
+            readonly pagesCommitted: Schema.NullOr<Schema.Int>;
+            readonly completedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        }>>;
+        readonly latestSynchronized: Schema.NullOr<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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+            readonly attemptSequence: Schema.Int;
+            readonly startedRevision: Schema.Int;
+            readonly startedAt: Schema.DateTimeUtcFromString;
+            readonly outcome: Schema.NullOr<Schema.Literals<readonly ["synchronized", "source-unavailable", "interrupted"]>>;
+            readonly endingRevision: Schema.NullOr<Schema.Int>;
+            readonly pagesCommitted: Schema.NullOr<Schema.Int>;
+            readonly completedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        }>>;
+    }, "Type">, Schema.SchemaError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    getStream: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly revision: Schema.Int;
+        readonly checkpointJson: Schema.NullOr<Schema.String>;
+        readonly checkpointDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+        readonly lastPageId: Schema.NullOr<Schema.brand<Schema.String, "PluginPageId">>;
+        readonly synchronizedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">, RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    listEvidence: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly pageId: Schema.brand<Schema.String, "PluginPageId">;
+        readonly ordinal: Schema.Int;
+        readonly eventId: Schema.String;
+        readonly eventDigest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly eventKind: Schema.Literals<readonly ["upsert", "tombstone"]>;
+        readonly recordKey: Schema.brand<Schema.String, "PluginRecordKey">;
+        readonly sourceRevision: Schema.brand<Schema.String, "Revision">;
+        readonly payloadJson: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }, "Type">[], PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    listSyncAttempts: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">) => Effect.Effect<readonly Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+        readonly attemptSequence: Schema.Int;
+        readonly startedRevision: Schema.Int;
+        readonly startedAt: Schema.DateTimeUtcFromString;
+        readonly outcome: Schema.NullOr<Schema.Literals<readonly ["synchronized", "source-unavailable", "interrupted"]>>;
+        readonly endingRevision: Schema.NullOr<Schema.Int>;
+        readonly pagesCommitted: Schema.NullOr<Schema.Int>;
+        readonly completedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    }, "Type">[], Schema.SchemaError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    reconcileSyncAttempts: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, providerId: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify", streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">, completedAt: DateTime.Utc) => Effect.Effect<number, RecordNotFoundError | SourceIdentityMismatchError | PersistenceOperationError, never>;
+    releaseSyncClaim: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, streamKey: string & import("effect/Brand").Brand<"PluginStreamKey">, claimId: string) => Effect.Effect<void, PersistenceOperationError, never>;
+    recordHealth: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">, expectedRevision: number, health: Schema.Struct.ReadonlySide<{
+        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;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        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;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"healthy">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"disabled">;
+        readonly checkedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, consecutiveFailures: number) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        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 providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly revision: Schema.Int;
+        readonly descriptorGeneration: Schema.Int;
+        readonly descriptorSchemaVersion: Schema.Int;
+        readonly descriptorJson: Schema.String;
+        readonly descriptorDigest: Schema.brand<Schema.String, "BlobDigest">;
+        readonly acceptedAt: Schema.DateTimeUtcFromString;
+        readonly health: 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 consecutiveFailures: Schema.Int;
+    }, "Type">, unknown, never>;
+}, never, Crypto.Crypto | Database | QuarantineRepository>;
+/** Durable descriptor, health, checkpoint, last-valid cache, and evidence repository. */
+export interface PluginRuntimeRepositoryService extends Success<typeof makePluginRuntimeRepository> {
+}
+declare const PluginRuntimeRepository_base: Context.ServiceClass<PluginRuntimeRepository, "@knpkv/control-center/PluginRuntimeRepository", PluginRuntimeRepositoryService>;
+export declare class PluginRuntimeRepository extends PluginRuntimeRepository_base {
+    static readonly layer: Layer.Layer<PluginRuntimeRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+export {};
+//# sourceMappingURL=pluginRuntimeRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pluginRuntimeRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/pluginRuntimeRepository.ts"],"names":[],"mappings":"AAKA,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;AAGrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AASvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EAEnB,2BAA2B,EAC5B,MAAM,cAAc,CAAA;AAerB,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAgEhE,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DA4pC/B,CAAA;AAEF,yFAAyF;AACzF,MAAM,WAAW,8BAA+B,SAAQ,OAAO,CAAC,OAAO,2BAA2B,CAAC;CAAG;;AAEtG,qBAAa,uBAAwB,SAAQ,4BAGO;IAClD,MAAM,CAAC,QAAQ,CAAC,KAAK,+FAAqE;CAC3F"}

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

@@ -0,0 +1,150 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+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, RecordAlreadyExistsError, RecordNotFoundError } from "../errors.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+declare const ProviderAccountInputError_base: Schema.Class<ProviderAccountInputError, Schema.TaggedStruct<"ProviderAccountInputError", {
+    readonly operation: Schema.Literals<readonly ["follow-resource"]>;
+    readonly reason: Schema.Literals<readonly ["provider-family-mismatch"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Invalid provider/resource combination rejected before persistence. */
+export declare class ProviderAccountInputError extends ProviderAccountInputError_base {
+}
+declare const makeProviderAccountRepository: Effect.Effect<{
+    create: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: Omit<Schema.Struct.ReadonlySide<{
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly vendorAccountId: Schema.brand<Schema.String, "VendorAccountId">;
+        readonly displayName: Schema.brand<Schema.String, "ProviderAccountDisplayName">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+    }, "Type">, "workspaceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly vendorAccountId: Schema.brand<Schema.String, "VendorAccountId">;
+        readonly displayName: Schema.brand<Schema.String, "ProviderAccountDisplayName">;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | RecordAlreadyExistsError | import("../errors.js").PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    get: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, providerAccountId: string & import("effect/Brand").Brand<"ProviderAccountId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly vendorAccountId: Schema.brand<Schema.String, "VendorAccountId">;
+        readonly displayName: Schema.brand<Schema.String, "ProviderAccountDisplayName">;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | import("../errors.js").PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    list: (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 providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly vendorAccountId: Schema.brand<Schema.String, "VendorAccountId">;
+        readonly displayName: Schema.brand<Schema.String, "ProviderAccountDisplayName">;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">[], import("../errors.js").PersistenceOperationError | import("../errors.js").QuarantineWriteError, never>;
+    updateMetadata: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, providerAccountId: string & import("effect/Brand").Brand<"ProviderAccountId">, input: Omit<Schema.Struct.ReadonlySide<{
+        readonly displayName: Schema.brand<Schema.String, "ProviderAccountDisplayName">;
+        readonly expectedRevision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+    }, "Type">, "workspaceId" | "providerAccountId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly vendorAccountId: Schema.brand<Schema.String, "VendorAccountId">;
+        readonly displayName: Schema.brand<Schema.String, "ProviderAccountDisplayName">;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, unknown, never>;
+    followResource: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: Omit<Schema.Struct.ReadonlySide<{
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly vendorResourceId: Schema.brand<Schema.String, "VendorResourceId">;
+        readonly displayName: Schema.brand<Schema.String, "FollowedResourceDisplayName">;
+        readonly isEnabled: Schema.Boolean;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly followedResourceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">;
+    }, "Type">, "workspaceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly followedResourceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly vendorResourceId: Schema.brand<Schema.String, "VendorResourceId">;
+        readonly displayName: Schema.brand<Schema.String, "FollowedResourceDisplayName">;
+        readonly isEnabled: Schema.Boolean;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, Schema.SchemaError | RecordNotFoundError | RecordAlreadyExistsError | import("../errors.js").PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError | ProviderAccountInputError, never>;
+    getResource: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, followedResourceId: string & import("effect/Brand").Brand<"FollowedResourceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly followedResourceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly vendorResourceId: Schema.brand<Schema.String, "VendorResourceId">;
+        readonly displayName: Schema.brand<Schema.String, "FollowedResourceDisplayName">;
+        readonly isEnabled: Schema.Boolean;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, Schema.SchemaError | RecordNotFoundError | import("../errors.js").PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    listResources: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, providerAccountId: string & import("effect/Brand").Brand<"ProviderAccountId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly followedResourceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly vendorResourceId: Schema.brand<Schema.String, "VendorResourceId">;
+        readonly displayName: Schema.brand<Schema.String, "FollowedResourceDisplayName">;
+        readonly isEnabled: Schema.Boolean;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">[], Schema.SchemaError | RecordNotFoundError | import("../errors.js").PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    updateResourceMetadata: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, followedResourceId: string & import("effect/Brand").Brand<"FollowedResourceId">, input: Omit<Schema.Struct.ReadonlySide<{
+        readonly displayName: Schema.brand<Schema.String, "FollowedResourceDisplayName">;
+        readonly isEnabled: Schema.Boolean;
+        readonly expectedRevision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly followedResourceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">;
+    }, "Type">, "workspaceId" | "followedResourceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly followedResourceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "FollowedResourceId">;
+        readonly providerAccountId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProviderAccountId">;
+        readonly providerFamily: Schema.Literals<readonly ["aws", "atlassian", "clockify"]>;
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly vendorResourceId: Schema.brand<Schema.String, "VendorResourceId">;
+        readonly displayName: Schema.brand<Schema.String, "FollowedResourceDisplayName">;
+        readonly isEnabled: Schema.Boolean;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, unknown, never>;
+}, never, Crypto.Crypto | Database | QuarantineRepository>;
+/** Provider accounts with their independently followed resources. */
+export interface ProviderAccountRepositoryService extends Success<typeof makeProviderAccountRepository> {
+}
+declare const ProviderAccountRepository_base: Context.ServiceClass<ProviderAccountRepository, "@knpkv/control-center/ProviderAccountRepository", ProviderAccountRepositoryService>;
+/** Effect service for provider-account and followed-resource persistence. */
+export declare class ProviderAccountRepository extends ProviderAccountRepository_base {
+    /** Layer binding account and resource plans to the shared database. */
+    static readonly layer: Layer.Layer<ProviderAccountRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+export {};
+//# sourceMappingURL=providerAccountRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"providerAccountRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/providerAccountRepository.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAqBlG,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;;;;;AAEhE,yEAAyE;AACzE,qBAAa,yBAA0B,SAAQ,8BAM9C;CAAG;AA2DJ,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DA+PjC,CAAA;AAEF,qEAAqE;AACrE,MAAM,WAAW,gCAAiC,SAAQ,OAAO,CAAC,OAAO,6BAA6B,CAAC;CAAG;;AAE1G,6EAA6E;AAC7E,qBAAa,yBAA0B,SAAQ,8BAGO;IACpD,uEAAuE;IACvE,MAAM,CAAC,QAAQ,CAAC,KAAK,iGAAyE;CAC/F"}