@knpkv/control-center 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"readinessRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/readinessRepository.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,294 @@
+import * as Context from "effect/Context";
+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, RecordAlreadyExistsError, RecordNotFoundError } from "../errors.js";
+declare const RelationshipRepairProposalInputError_base: Schema.Class<RelationshipRepairProposalInputError, Schema.TaggedStruct<"RelationshipRepairProposalInputError", {
+    readonly operation: Schema.Literals<readonly ["application", "create", "get", "list", "list-applications", "record-application", "review"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Raised when a relationship-repair persistence command fails boundary decoding. */
+export declare class RelationshipRepairProposalInputError extends RelationshipRepairProposalInputError_base {
+}
+/** Caller intent for one durable pending relationship-repair proposal. */
+export declare const CreateRelationshipRepairProposalInput: Schema.Struct<{
+    readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+    readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+    readonly expectedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+    readonly disposition: Schema.Literals<readonly ["link", "verify", "reject"]>;
+    readonly rationale: Schema.String;
+    readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    }>;
+    readonly proposedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded durable relationship-repair proposal intent. */
+export type CreateRelationshipRepairProposalInput = typeof CreateRelationshipRepairProposalInput.Type;
+/** Workspace-scoped proposal lookup. */
+export declare const ReadRelationshipRepairProposalInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+}>;
+/** Bounded release/environment proposal query. */
+export declare const ListRelationshipRepairProposalsInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+    readonly status: Schema.NullOr<Schema.Literals<readonly ["pending", "approved", "rejected"]>>;
+}>;
+/** Bounded release/environment application query matching the proposal page. */
+export declare const ListRelationshipRepairApplicationsInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+    readonly status: Schema.NullOr<Schema.Literals<readonly ["pending", "approved", "rejected"]>>;
+}>;
+/** Idempotent reviewer decision over one pending proposal. */
+export declare const ReviewRelationshipRepairProposalInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+    readonly reviewId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairReviewId">;
+    readonly decision: Schema.Literals<readonly ["approved", "rejected"]>;
+    readonly rationale: Schema.String;
+    readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    }>;
+    readonly reviewedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded immutable relationship-repair review command. */
+export type ReviewRelationshipRepairProposalInput = typeof ReviewRelationshipRepairProposalInput.Type;
+/** Workspace-scoped lookup for an existing proposal application. */
+export declare const ReadRelationshipRepairApplicationInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+}>;
+/** Owner-authorized record of an exact relationship revision appended by a proposal. */
+export declare const RecordRelationshipRepairApplicationInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+    readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+    readonly appliedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+    readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    }>;
+    readonly appliedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded relationship-repair application command. */
+export type RecordRelationshipRepairApplicationInput = typeof RecordRelationshipRepairApplicationInput.Type;
+declare const makeRelationshipRepairProposalRepository: Effect.Effect<{
+    application: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly appliedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly appliedAt: Schema.DateTimeUtcFromString;
+    }, "Type"> | null, PersistenceOperationError | PersistedRecordError | RelationshipRepairProposalInputError, never>;
+    create: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<2>;
+        readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly expectedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly disposition: Schema.Literals<readonly ["link", "verify", "reject"]>;
+        readonly rationale: Schema.String;
+        readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly status: Schema.Literals<readonly ["pending", "approved", "rejected"]>;
+        readonly proposedAt: Schema.DateTimeUtcFromString;
+        readonly review: Schema.NullOr<Schema.Struct<{
+            readonly reviewId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairReviewId">;
+            readonly decision: Schema.Literals<readonly ["approved", "rejected"]>;
+            readonly rationale: Schema.String;
+            readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }>;
+            readonly reviewedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }, "Type">, unknown, never>;
+    get: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<2>;
+        readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly expectedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly disposition: Schema.Literals<readonly ["link", "verify", "reject"]>;
+        readonly rationale: Schema.String;
+        readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly status: Schema.Literals<readonly ["pending", "approved", "rejected"]>;
+        readonly proposedAt: Schema.DateTimeUtcFromString;
+        readonly review: Schema.NullOr<Schema.Struct<{
+            readonly reviewId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairReviewId">;
+            readonly decision: Schema.Literals<readonly ["approved", "rejected"]>;
+            readonly rationale: Schema.String;
+            readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }>;
+            readonly reviewedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }, "Type">, RecordNotFoundError | PersistenceOperationError | PersistedRecordError | RelationshipRepairProposalInputError, never>;
+    list: (input: unknown) => Effect.Effect<{
+        proposals: Schema.Struct.ReadonlySide<{
+            readonly schemaVersion: Schema.Literal<2>;
+            readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+            readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+            readonly expectedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+            readonly disposition: Schema.Literals<readonly ["link", "verify", "reject"]>;
+            readonly rationale: Schema.String;
+            readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }>;
+            readonly status: Schema.Literals<readonly ["pending", "approved", "rejected"]>;
+            readonly proposedAt: Schema.DateTimeUtcFromString;
+            readonly review: Schema.NullOr<Schema.Struct<{
+                readonly reviewId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairReviewId">;
+                readonly decision: Schema.Literals<readonly ["approved", "rejected"]>;
+                readonly rationale: Schema.String;
+                readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
+                readonly reviewedAt: Schema.DateTimeUtcFromString;
+            }>>;
+        }, "Type">[];
+        truncated: boolean;
+    }, PersistenceOperationError | PersistedRecordError | RelationshipRepairProposalInputError, never>;
+    listApplications: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly appliedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly appliedAt: Schema.DateTimeUtcFromString;
+    }, "Type">[], PersistenceOperationError | PersistedRecordError | RelationshipRepairProposalInputError, never>;
+    review: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly schemaVersion: Schema.Literal<2>;
+        readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+        readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly expectedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly disposition: Schema.Literals<readonly ["link", "verify", "reject"]>;
+        readonly rationale: Schema.String;
+        readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly status: Schema.Literals<readonly ["pending", "approved", "rejected"]>;
+        readonly proposedAt: Schema.DateTimeUtcFromString;
+        readonly review: Schema.NullOr<Schema.Struct<{
+            readonly reviewId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairReviewId">;
+            readonly decision: Schema.Literals<readonly ["approved", "rejected"]>;
+            readonly rationale: Schema.String;
+            readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            }>;
+            readonly reviewedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }, "Type">, RecordNotFoundError | RecordAlreadyExistsError | PersistenceOperationError | PersistedRecordError | RelationshipRepairProposalInputError, never>;
+    recordApplication: (input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+        readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+        readonly appliedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+        readonly origin: 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 sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly appliedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, PersistenceOperationError | PersistedRecordError | RelationshipRepairProposalInputError, never>;
+}, never, Database>;
+/** Workspace-scoped durable relationship-repair proposal persistence. */
+export interface RelationshipRepairProposalRepositoryService extends Success<typeof makeRelationshipRepairProposalRepository> {
+}
+declare const RelationshipRepairProposalRepository_base: Context.ServiceClass<RelationshipRepairProposalRepository, "@knpkv/control-center/RelationshipRepairProposalRepository", RelationshipRepairProposalRepositoryService>;
+/** Server-only repository for relationship-repair proposals and immutable reviews. */
+export declare class RelationshipRepairProposalRepository extends RelationshipRepairProposalRepository_base {
+    /** Layer binding proposal persistence to the shared database. */
+    static readonly layer: Layer.Layer<RelationshipRepairProposalRepository, never, Database>;
+}
+export {};
+//# sourceMappingURL=relationshipRepairProposalRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relationshipRepairProposalRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/relationshipRepairProposalRepository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,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;AAyBvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,cAAc,CAAA;;;;AAOrB,qFAAqF;AACrF,qBAAa,oCAAqC,SAAQ,yCAYxD;CAAG;AAEL,0EAA0E;AAC1E,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;EAWhD,CAAA;AAEF,2DAA2D;AAC3D,MAAM,MAAM,qCAAqC,GAAG,OAAO,qCAAqC,CAAC,IAAI,CAAA;AAErG,wCAAwC;AACxC,eAAO,MAAM,mCAAmC;;;EAG9C,CAAA;AAEF,kDAAkD;AAClD,eAAO,MAAM,oCAAoC;;;;;EAK/C,CAAA;AAEF,gFAAgF;AAChF,eAAO,MAAM,uCAAuC;;;;;EAAuC,CAAA;AAE3F,8DAA8D;AAC9D,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;EAQhD,CAAA;AAEF,4DAA4D;AAC5D,MAAM,MAAM,qCAAqC,GAAG,OAAO,qCAAqC,CAAC,IAAI,CAAA;AAErG,oEAAoE;AACpE,eAAO,MAAM,sCAAsC;;;EAAsC,CAAA;AAEzF,wFAAwF;AACxF,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;EAOnD,CAAA;AAEF,uDAAuD;AACvD,MAAM,MAAM,wCAAwC,GAAG,OAAO,wCAAwC,CAAC,IAAI,CAAA;AAuF3G,QAAA,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2d5C,CAAA;AAEF,yEAAyE;AACzE,MAAM,WAAW,2CACf,SAAQ,OAAO,CAAC,OAAO,wCAAwC,CAAC;CAChE;;AAEF,sFAAsF;AACtF,qBAAa,oCAAqC,SAAQ,yCAGO;IAC/D,iEAAiE;IACjE,MAAM,CAAC,QAAQ,CAAC,KAAK,qEAGpB;CACF"}