@knpkv/control-center 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"releaseRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/releaseRepository.ts"],"names":[],"mappings":"AAAA,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;AAE5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAGrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EAAiB,SAAS,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAGtF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,2BAA2B,EAC5B,MAAM,cAAc,CAAA;AAgBrB,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAehE,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,8CAEW,CAAA;AAExC,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AA6B3D,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAoeJ,WAAW,aAAa,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAwGtD,CAAA;AAEF,iFAAiF;AACjF,MAAM,WAAW,wBAAyB,SAAQ,OAAO,CAAC,OAAO,qBAAqB,CAAC;CAAG;;AAE1F,wDAAwD;AACxD,qBAAa,iBAAkB,SAAQ,sBAEtC;IACC,+EAA+E;IAC/E,MAAM,CAAC,QAAQ,CAAC,KAAK,yFAAyD;CAC/E"}

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

@@ -0,0 +1,39 @@
+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";
+declare const TimelineExportAuditInputError_base: Schema.Class<TimelineExportAuditInputError, Schema.TaggedStruct<"TimelineExportAuditInputError", {}>, import("effect/Cause").YieldableError>;
+/** Raised when Timeline export audit persistence input is invalid. */
+export declare class TimelineExportAuditInputError extends TimelineExportAuditInputError_base {
+}
+/** One immutable attribution record for a successfully collected Timeline export. */
+export declare const RecordTimelineExportAuditInput: Schema.Struct<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    readonly format: Schema.Literals<readonly ["csv", "json"]>;
+    readonly actorKind: Schema.NullOr<Schema.Literals<readonly ["agent", "human", "plugin", "system"]>>;
+    readonly from: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    readonly to: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    readonly requestedLimit: Schema.Int;
+    readonly returnedCount: Schema.Int;
+    readonly truncated: Schema.Boolean;
+}>;
+/** Decoded Timeline export audit append command. */
+export type RecordTimelineExportAuditInput = typeof RecordTimelineExportAuditInput.Type;
+declare const makeTimelineExportAuditRepository: Effect.Effect<{
+    record: (input: unknown) => Effect.Effect<void, import("../errors.ts").PersistenceOperationError | import("effect/PlatformError").PlatformError | TimelineExportAuditInputError, never>;
+}, never, Crypto.Crypto | Database>;
+/** Durable append-only Timeline export audit repository service. */
+export interface TimelineExportAuditRepositoryService extends Success<typeof makeTimelineExportAuditRepository> {
+}
+declare const TimelineExportAuditRepository_base: Context.ServiceClass<TimelineExportAuditRepository, "@knpkv/control-center/server/persistence/TimelineExportAuditRepository", TimelineExportAuditRepositoryService>;
+/** Private Timeline export attribution repository. */
+export declare class TimelineExportAuditRepository extends TimelineExportAuditRepository_base {
+    static readonly layer: Layer.Layer<TimelineExportAuditRepository, never, Crypto.Crypto | Database>;
+}
+export {};
+//# sourceMappingURL=timelineExportAuditRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timelineExportAuditRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/timelineExportAuditRepository.ts"],"names":[],"mappings":"AAAA,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;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;;AAGzC,sEAAsE;AACtE,qBAAa,6BAA8B,SAAQ,kCAGlD;CAAG;AAEJ,qFAAqF;AACrF,eAAO,MAAM,8BAA8B;;;;;;;;;;;EAgB1C,CAAA;AAED,oDAAoD;AACpD,MAAM,MAAM,8BAA8B,GAAG,OAAO,8BAA8B,CAAC,IAAI,CAAA;AAEvF,QAAA,MAAM,iCAAiC;;mCAyBrC,CAAA;AAEF,oEAAoE;AACpE,MAAM,WAAW,oCAAqC,SAAQ,OAAO,CAAC,OAAO,iCAAiC,CAAC;CAAG;;AAElH,sDAAsD;AACtD,qBAAa,6BAA8B,SAAQ,kCAG0B;IAC3E,MAAM,CAAC,QAAQ,CAAC,KAAK,8EAAiF;CACvG"}

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

@@ -0,0 +1,84 @@
+import * as Context from "effect/Context";
+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 type { EntityId, WorkspaceId } from "../../../domain/identifiers.js";
+import type { TimelineActorKind, TimelineCursor, TimelineService, TimelineSourceKind } from "../../../domain/timeline.js";
+import type { UtcTimestamp } from "../../../domain/utcTimestamp.js";
+import { Database } from "../Database.js";
+/** Trusted durable Timeline row after SQL result decoding. */
+export interface TimelineRecord {
+    readonly eventKey: string;
+    readonly occurredAt: UtcTimestamp;
+    readonly actorKind: TimelineActorKind;
+    readonly actorId: string | null;
+    readonly actorLabel: string | null;
+    readonly eventType: string;
+    readonly sourceKind: TimelineSourceKind;
+    readonly service: TimelineService | null;
+    readonly releaseId: string | null;
+    readonly entityId: string | null;
+    readonly actionId: string | null;
+    readonly relationshipId: string | null;
+    readonly pluginConnectionId: string | null;
+    readonly agentJobId: string | null;
+}
+/** Workspace-safe inputs for one bounded newest-first Timeline page. */
+export interface ReadTimelinePageInput {
+    readonly actorKind: TimelineActorKind | null;
+    readonly before: TimelineCursor | null;
+    readonly entityId: EntityId | null;
+    readonly from: UtcTimestamp | null;
+    readonly limit: number;
+    readonly to: UtcTimestamp | null;
+    readonly workspaceId: WorkspaceId;
+}
+declare const makeTimelineRepository: Effect.Effect<{
+    page: (input: ReadTimelinePageInput) => Effect.Effect<{
+        actorKind: "plugin" | "human" | "agent" | "system";
+        occurredAt: DateTime.Utc;
+        service: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify" | null;
+        sourceKind: "relationship" | "system" | "action" | "plugin-sync";
+        eventKey: string;
+        actorId: string | null;
+        actorLabel: string | null;
+        eventType: string;
+        releaseId: string | null;
+        entityId: string | null;
+        actionId: string | null;
+        relationshipId: string | null;
+        pluginConnectionId: string | null;
+        agentJobId: string | null;
+    }[], import("../errors.ts").PersistenceOperationError, never>;
+    detail: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly eventKey: string;
+    }) => Effect.Effect<{
+        actorKind: "plugin" | "human" | "agent" | "system";
+        occurredAt: DateTime.Utc;
+        service: "codecommit" | "codepipeline" | "jira" | "confluence" | "clockify" | null;
+        sourceKind: "relationship" | "system" | "action" | "plugin-sync";
+        eventKey: string;
+        actorId: string | null;
+        actorLabel: string | null;
+        eventType: string;
+        releaseId: string | null;
+        entityId: string | null;
+        actionId: string | null;
+        relationshipId: string | null;
+        pluginConnectionId: string | null;
+        agentJobId: string | null;
+    } | null, import("../errors.ts").PersistenceOperationError, never>;
+}, never, Database>;
+/** Deep persistence interface for the merged durable activity Timeline. */
+export interface TimelineRepositoryService extends Success<typeof makeTimelineRepository> {
+}
+declare const TimelineRepository_base: Context.ServiceClass<TimelineRepository, "@knpkv/control-center/TimelineRepository", TimelineRepositoryService>;
+/** Effect service exposing bounded Timeline reads. */
+export declare class TimelineRepository extends TimelineRepository_base {
+    /** Layer binding Timeline reads to the shared database. */
+    static readonly layer: Layer.Layer<TimelineRepository, never, Database>;
+}
+export {};
+//# sourceMappingURL=timelineRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timelineRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/timelineRepository.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAGrC,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAC3E,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,kBAAkB,EACnB,MAAM,6BAA6B,CAAA;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAoBzC,8DAA8D;AAC9D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAA;IACvC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IACtC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CACnC;AAED,wEAAwE;AACxE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAC5C,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAA;IACtC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAA;IAClC,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAA;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAClC;AASD,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;8BA8CA,WAAW;2BACd,MAAM;;;;;;;;;;;;;;;;;mBAO7B,CAAA;AAEF,2EAA2E;AAC3E,MAAM,WAAW,yBAA0B,SAAQ,OAAO,CAAC,OAAO,sBAAsB,CAAC;CAAG;;AAE5F,sDAAsD;AACtD,qBAAa,kBAAmB,SAAQ,uBAEvC;IACC,2DAA2D;IAC3D,MAAM,CAAC,QAAQ,CAAC,KAAK,mDAA2D;CACjF"}

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

@@ -0,0 +1,52 @@
+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 { UtcTimestamp } from "../../../domain/utcTimestamp.js";
+import { Database } from "../Database.js";
+import { PersistedRecordError, RecordNotFoundError } from "../errors.js";
+import { RecordRevision, WorkspaceName } from "./models.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+declare const makeWorkspaceRepository: Effect.Effect<{
+    create: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: {
+        readonly displayName: WorkspaceName;
+        readonly createdAt: UtcTimestamp;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly displayName: Schema.brand<Schema.String, "WorkspaceName">;
+        readonly revision: Schema.brand<Schema.Number, "RecordRevision">;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly updatedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | import("../errors.js").RecordAlreadyExistsError | import("../errors.js").PersistenceOperationError | PersistedRecordError | import("../errors.js").QuarantineWriteError, never>;
+    get: (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 displayName: Schema.brand<Schema.String, "WorkspaceName">;
+        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>;
+    updateDisplayName: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: {
+        readonly displayName: WorkspaceName;
+        readonly expectedRevision: RecordRevision;
+        readonly updatedAt: UtcTimestamp;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly displayName: Schema.brand<Schema.String, "WorkspaceName">;
+        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 persistence with optimistic-concurrency updates. */
+export interface WorkspaceRepositoryService extends Success<typeof makeWorkspaceRepository> {
+}
+declare const WorkspaceRepository_base: Context.ServiceClass<WorkspaceRepository, "@knpkv/control-center/WorkspaceRepository", WorkspaceRepositoryService>;
+/** Effect service for workspace records. */
+export declare class WorkspaceRepository extends WorkspaceRepository_base {
+    /** Layer that binds SQL queries to the shared database at construction. */
+    static readonly layer: Layer.Layer<WorkspaceRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+export {};
+//# sourceMappingURL=workspaceRepository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspaceRepository.d.ts","sourceRoot":"","sources":["../../../../../src/server/persistence/repositories/workspaceRepository.ts"],"names":[],"mappings":"AAAA,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;AAIvC,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAQxE,OAAO,EAAE,cAAc,EAAE,aAAa,EAAmB,MAAM,aAAa,CAAA;AAE5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAehE,QAAA,MAAM,uBAAuB;;8BAoEQ,aAAa;4BAAsB,YAAY;;;;;;;;;;;;;;;;8BAYtD,aAAa;mCACR,cAAc;4BACrB,YAAY;;;;;;;;0DAuBtC,CAAA;AAEF,wEAAwE;AACxE,MAAM,WAAW,0BAA2B,SAAQ,OAAO,CAAC,OAAO,uBAAuB,CAAC;CAAG;;AAE9F,4CAA4C;AAC5C,qBAAa,mBAAoB,SAAQ,wBAExC;IACC,2EAA2E;IAC3E,MAAM,CAAC,QAAQ,CAAC,KAAK,2FAA6D;CACnF"}

package/dist/server/server/persistence/schema.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import type * as SqlClient from "effect/unstable/sql/SqlClient";
+import { DatabaseInitializationError } from "./errors.js";
+/** Unstable schema identity stored in prototype backup manifests. */
+export declare const CURRENT_SCHEMA_VERSION: "unstable";
+/** Require the exact current prototype schema without compatibility handling. */
+export declare const validateCurrentSchema: (sql: SqlClient.SqlClient) => Effect.Effect<undefined, DatabaseInitializationError, never>;
+/**
+ * Initialize a brand-new prototype database or require the exact current shape.
+ *
+ * Start versioned migrations only after the persistence model is declared stable
+ * and a released database file must remain readable by a newer application build.
+ * Until then, schema changes are intentionally breaking and require recreating the
+ * local database.
+ */
+export declare const initializeCurrentSchema: (sql: SqlClient.SqlClient) => Effect.Effect<undefined, DatabaseInitializationError, never>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/server/server/persistence/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/server/persistence/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAgBzD,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,YAAwB,CAAA;AA4B3D,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,4FAOhC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,4FAUlC,CAAA"}

package/dist/server/server/persistence/schemas.d.ts

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+/** Decoded SQLite foreign-key pragma result. */
+export declare const ForeignKeysPragmaRow: Schema.Struct<{
+    readonly foreignKeys: Schema.Number;
+}>;
+/** Decoded SQLite journal-mode pragma result. */
+export declare const JournalModePragmaRow: Schema.Struct<{
+    readonly journalMode: Schema.String;
+}>;
+/** Decoded SQLite busy-timeout pragma result. */
+export declare const BusyTimeoutPragmaRow: Schema.Struct<{
+    readonly timeout: Schema.Number;
+}>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/server/server/persistence/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/server/persistence/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,gDAAgD;AAChD,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AAEF,iDAAiD;AACjD,eAAO,MAAM,oBAAoB;;EAE/B,CAAA;AAEF,iDAAiD;AACjD,eAAO,MAAM,oBAAoB;;EAE/B,CAAA"}

package/dist/server/server/plugins/AtlassianBasicAuth.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AtlassianBasicAuth.d.ts.map

package/dist/server/server/plugins/AtlassianBasicAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AtlassianBasicAuth.d.ts","sourceRoot":"","sources":["../../../../src/server/plugins/AtlassianBasicAuth.ts"],"names":[],"mappings":""}

package/dist/server/server/plugins/PluginCapabilityCodecs.d.ts

@@ -0,0 +1,357 @@
+import { AuthorizedPluginActionV1, DiffContentRangeRequestV1, DiffContentRangeV1, DiffInventoryPageRequestV1, DiffInventoryPageV1, PluginActionCancellationRequestV1, PluginActionCancellationResultV1, PluginActionDispatchResultV1, PluginActionPreflightV1, PluginActionProposalV1, PluginActionReconciliationRequestV1, PluginActionReconciliationResultV1, PluginSyncPageV1, PluginSyncRequestV1, ProposePluginActionRequestV1, ReadPluginEntityRequestV1, ReadPluginEntityResultV1 } from "../../domain/plugins/index.js";
+interface CapabilityCodecV1 {
+    readonly version: 1;
+}
+/** Adapter-registered codecs for every version-one capability boundary it offers. */
+export interface PluginCapabilityCodecsV1 {
+    readonly entityRead?: CapabilityCodecV1 & {
+        readonly input: typeof ReadPluginEntityRequestV1;
+        readonly output: typeof ReadPluginEntityResultV1;
+    };
+    readonly syncIncremental?: CapabilityCodecV1 & {
+        readonly input: typeof PluginSyncRequestV1;
+        readonly output: typeof PluginSyncPageV1;
+    };
+    readonly actionPropose?: CapabilityCodecV1 & {
+        readonly input: typeof ProposePluginActionRequestV1;
+        readonly output: typeof PluginActionProposalV1;
+    };
+    readonly actionExecute?: CapabilityCodecV1 & {
+        readonly input: typeof AuthorizedPluginActionV1;
+        readonly preflightOutput: typeof PluginActionPreflightV1;
+        readonly dispatchOutput: typeof PluginActionDispatchResultV1;
+    };
+    readonly actionCancel?: CapabilityCodecV1 & {
+        readonly input: typeof PluginActionCancellationRequestV1;
+        readonly output: typeof PluginActionCancellationResultV1;
+    };
+    readonly actionReconcile?: CapabilityCodecV1 & {
+        readonly input: typeof PluginActionReconciliationRequestV1;
+        readonly output: typeof PluginActionReconciliationResultV1;
+    };
+    readonly diffInventory?: CapabilityCodecV1 & {
+        readonly input: typeof DiffInventoryPageRequestV1;
+        readonly output: typeof DiffInventoryPageV1;
+    };
+    readonly diffContent?: CapabilityCodecV1 & {
+        readonly input: typeof DiffContentRangeRequestV1;
+        readonly output: typeof DiffContentRangeV1;
+    };
+}
+/** Canonical host codecs adapters explicitly register for negotiated v1 capabilities. */
+export declare const pluginCapabilityCodecsV1: {
+    entityRead: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+        }>;
+        output: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"found", {
+            readonly event: import("effect/Schema").TaggedStruct<"UpsertEntity", {
+                readonly sourceUrl: import("effect/Schema").NullOr<import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>>;
+                readonly title: import("effect/Schema").String;
+                readonly attributes: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+                readonly entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                readonly eventId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            }>;
+        }>, import("effect/Schema").TaggedStruct<"missing", {
+            readonly reference: import("effect/Schema").Struct<{
+                entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+            }>;
+            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>]>;
+    };
+    syncIncremental: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            readonly streamKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly checkpoint: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+        }>;
+        output: import("effect/Schema").Struct<{
+            readonly events: import("effect/Schema").$Array<import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"UpsertEntity", {
+                readonly sourceUrl: import("effect/Schema").NullOr<import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>>;
+                readonly title: import("effect/Schema").String;
+                readonly attributes: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+                readonly entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                readonly eventId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            }>, import("effect/Schema").TaggedStruct<"TombstoneEntity", {
+                readonly reason: import("effect/Schema").String;
+                readonly entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                readonly eventId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            }>, import("effect/Schema").TaggedStruct<"AppendEvidence", {
+                readonly evidenceId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly subject: import("effect/Schema").Struct<{
+                    entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                }>;
+                readonly evidenceType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly summary: import("effect/Schema").String;
+                readonly capturedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly data: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly eventId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            }>, import("effect/Schema").TaggedStruct<"UpsertPerson", {
+                readonly vendorPersonId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly displayName: import("effect/Schema").String;
+                readonly avatarUrl: import("effect/Schema").NullOr<import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>>;
+                readonly active: import("effect/Schema").Boolean;
+                readonly eventId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            }>, import("effect/Schema").TaggedStruct<"ProposeRelationship", {
+                readonly relationshipId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly from: import("effect/Schema").Struct<{
+                    entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                }>;
+                readonly to: import("effect/Schema").Struct<{
+                    entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                }>;
+                readonly relationshipType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly confidence: import("effect/Schema").Number;
+                readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                readonly eventId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+                readonly revision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            }>]>>;
+            readonly checkpointAfterPage: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly hasMore: import("effect/Schema").Boolean;
+        }>;
+    };
+    actionPropose: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly target: import("effect/Schema").Struct<{
+                entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+            }>;
+            readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+        }>;
+        output: import("effect/Schema").Struct<{
+            readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly capabilityVersion: import("effect/Schema").Int;
+            readonly request: import("effect/Schema").Struct<{
+                readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly target: import("effect/Schema").Struct<{
+                    entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                }>;
+                readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+            }>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly summary: import("effect/Schema").String;
+            readonly impact: import("effect/Schema").Struct<{
+                readonly level: import("effect/Schema").Literals<readonly ["low", "medium", "high", "critical"]>;
+                readonly summary: import("effect/Schema").String;
+            }>;
+            readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>;
+    };
+    actionExecute: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            readonly proposal: import("effect/Schema").Struct<{
+                readonly proposalKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly capabilityVersion: import("effect/Schema").Int;
+                readonly request: import("effect/Schema").Struct<{
+                    readonly actionKind: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                    readonly target: import("effect/Schema").Struct<{
+                        entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                        vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+                    readonly payload: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                    readonly evidenceIds: import("effect/Schema").$Array<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+                }>;
+                readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+                readonly summary: import("effect/Schema").String;
+                readonly impact: import("effect/Schema").Struct<{
+                    readonly level: import("effect/Schema").Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: import("effect/Schema").String;
+                }>;
+                readonly proposedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+            readonly authorizationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly authorizedAt: import("effect/Schema").DateTimeUtcFromString;
+            readonly expiresAt: import("effect/Schema").DateTimeUtcFromString;
+        }>;
+        preflightOutput: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"ready", {
+            readonly checkedRevision: import("effect/Schema").brand<import("effect/Schema").String, "Revision">;
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>, import("effect/Schema").TaggedStruct<"blocked", {
+            readonly reasons: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>]>;
+        dispatchOutput: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"confirmed", {
+            readonly receipt: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literal<"accepted">;
+                readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>, import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>]>;
+        }>, import("effect/Schema").TaggedStruct<"unknown", {
+            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly safeSummary: import("effect/Schema").String;
+            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>]>;
+    };
+    actionCancel: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly providerOperationId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+        }>;
+        output: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"cancelled">;
+            readonly receipt: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literal<"accepted">;
+                readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>, import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>]>;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"completed">;
+            readonly receipt: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literal<"accepted">;
+                readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>, import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>]>;
+        }>, import("effect/Schema").TaggedStruct<"unknown", {
+            readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>]>;
+    };
+    actionReconcile: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            readonly reconciliationKey: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+            readonly idempotencyKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+            readonly payloadDigest: import("effect/Schema").brand<import("effect/Schema").String, "PluginActionPayloadDigest">;
+        }>;
+        output: import("effect/Schema").toTaggedUnion<"_tag", readonly [import("effect/Schema").TaggedStruct<"pending", {
+            readonly checkedAt: import("effect/Schema").DateTimeUtcFromString;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"succeeded">;
+            readonly receipt: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literal<"accepted">;
+                readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>, import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>]>;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"failed">;
+            readonly receipt: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literal<"accepted">;
+                readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>, import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>]>;
+        }>, import("effect/Schema").Struct<{
+            readonly _tag: import("effect/Schema").tag<"cancelled">;
+            readonly receipt: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literal<"accepted">;
+                readonly reconciliationKey: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>, import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                readonly providerOperationId: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                readonly safeSummary: import("effect/Schema").String;
+                readonly observedAt: import("effect/Schema").DateTimeUtcFromString;
+            }>]>;
+        }>]>;
+    };
+    diffInventory: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            readonly entity: import("effect/Schema").Struct<{
+                entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+            }>;
+            readonly cursor: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+        }>;
+        output: import("effect/Schema").Struct<{
+            readonly entries: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly path: import("effect/Schema").brand<import("effect/Schema").String, "PluginRelativePathV1">;
+                readonly previousPath: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "PluginRelativePathV1">>;
+                readonly status: import("effect/Schema").Literals<readonly ["added", "modified", "deleted", "renamed", "copied"]>;
+                readonly binary: import("effect/Schema").Boolean;
+                readonly generated: import("effect/Schema").Boolean;
+                readonly oversized: import("effect/Schema").Boolean;
+            }>>;
+            readonly nextCursor: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, string>>;
+        }>;
+    };
+    diffContent: {
+        version: 1;
+        input: import("effect/Schema").Struct<{
+            readonly entity: import("effect/Schema").Struct<{
+                entityType: import("effect/Schema").brand<import("effect/Schema").String, string>;
+                vendorImmutableId: import("effect/Schema").brand<import("effect/Schema").String, "VendorImmutableId">;
+            }>;
+            readonly path: import("effect/Schema").brand<import("effect/Schema").String, "PluginRelativePathV1">;
+            readonly side: import("effect/Schema").Literals<readonly ["before", "after"]>;
+            readonly offset: import("effect/Schema").Int;
+            readonly length: import("effect/Schema").Int;
+        }>;
+        output: import("effect/Schema").Struct<{
+            readonly bytesBase64: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            readonly totalBytes: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+            readonly unavailableReason: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["binary", "generated", "oversized", "missing", "provider-unavailable"]>>;
+        }>;
+    };
+};
+export {};
+//# sourceMappingURL=PluginCapabilityCodecs.d.ts.map