@orthacms/copilot-server 0.0.0-reserve.0

package/dist/lib/chat/infrastructure/schema/messages.d.ts

@@ -0,0 +1,264 @@
+import type { AttachmentRef, ModelContentBlock, SkillRef } from '@orthacms/copilot-domain';
+/** Who produced a turn. Mirrors the port's `ModelMessage['role']`. */
+export declare const copilotMessageRole: import("drizzle-orm/pg-core").PgEnum<["user", "assistant"]>;
+/**
+ * One turn of a conversation — **append-only**. This is the transcript used for
+ * replay and audit, so a row is never edited after it is written: a turn that
+ * failed keeps its `stopReason`, and a turn that was cancelled keeps whatever
+ * text had streamed. Rewriting history here would defeat the point of having it.
+ *
+ * The user's message is written **before** the model is called (design §5, step
+ * 3), so a dropped connection never loses what someone typed.
+ */
+export declare const copilotMessages: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "copilot_messages";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "copilot_messages";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        conversationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "conversation_id";
+            tableName: "copilot_messages";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "copilot_messages";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "copilot_messages";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "user" | "assistant";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["user", "assistant"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        content: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content";
+            tableName: "copilot_messages";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ModelContentBlock[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ModelContentBlock[];
+        }>;
+        attachments: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attachments";
+            tableName: "copilot_messages";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: AttachmentRef[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: AttachmentRef[];
+        }>;
+        skills: import("drizzle-orm/pg-core").PgColumn<{
+            name: "skills";
+            tableName: "copilot_messages";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: SkillRef[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: SkillRef[];
+        }>;
+        model: import("drizzle-orm/pg-core").PgColumn<{
+            name: "model";
+            tableName: "copilot_messages";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "copilot_messages";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stopReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stop_reason";
+            tableName: "copilot_messages";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        inputTokens: import("drizzle-orm/pg-core").PgColumn<{
+            name: "input_tokens";
+            tableName: "copilot_messages";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        outputTokens: import("drizzle-orm/pg-core").PgColumn<{
+            name: "output_tokens";
+            tableName: "copilot_messages";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        position: import("drizzle-orm/pg-core").PgColumn<{
+            name: "position";
+            tableName: "copilot_messages";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "copilot_messages";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/lib/chat/infrastructure/schema/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../../src/lib/chat/infrastructure/schema/messages.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACR,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACX,MAAM,0BAA0B,CAAC;AAGlC,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,6DAG7B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmF3B,CAAC"}

package/dist/lib/chat/infrastructure/schema/messages.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copilotMessages = exports.copilotMessageRole = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const conversations_1 = require("./conversations");
+/** Who produced a turn. Mirrors the port's `ModelMessage['role']`. */
+exports.copilotMessageRole = (0, pg_core_1.pgEnum)('copilot_message_role', [
+    'user',
+    'assistant'
+]);
+/**
+ * One turn of a conversation — **append-only**. This is the transcript used for
+ * replay and audit, so a row is never edited after it is written: a turn that
+ * failed keeps its `stopReason`, and a turn that was cancelled keeps whatever
+ * text had streamed. Rewriting history here would defeat the point of having it.
+ *
+ * The user's message is written **before** the model is called (design §5, step
+ * 3), so a dropped connection never loses what someone typed.
+ */
+exports.copilotMessages = (0, pg_core_1.pgTable)('copilot_messages', {
+    /** Primary key. */
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    /** The thread this turn belongs to. */
+    conversationId: (0, pg_core_1.uuid)('conversation_id')
+        .notNull()
+        .references(() => conversations_1.copilotConversations.id, { onDelete: 'cascade' }),
+    /**
+     * The run that produced this turn. The user message that opened the
+     * run carries the same id, so one run's turns select together.
+     */
+    runId: (0, pg_core_1.uuid)('run_id').notNull(),
+    /** Who produced the turn. */
+    role: (0, exports.copilotMessageRole)('role').notNull(),
+    /**
+     * The turn's content blocks, exactly as the port models them — text,
+     * tool_use and tool_result. Stored as the port's shape rather than a
+     * provider's, so a transcript survives switching provider.
+     */
+    content: (0, pg_core_1.jsonb)('content').$type().notNull(),
+    /**
+     * Files the user attached to this turn, resolved at send time. Null on
+     * an assistant turn and on a user turn with none.
+     *
+     * Its own column rather than another `content` block, for two reasons.
+     * The port's `ModelContentBlock` union is what every adapter switches
+     * on, so a sixth member would be a change to three adapters for
+     * something no provider needs to see; and the transcript read wants
+     * this **structured** — the panel renders attachments as chips, and
+     * recovering them by sniffing a text block's prefix is the kind of
+     * parsing that works until someone types the prefix.
+     *
+     * The engine folds them back into a fenced text block when it builds
+     * model messages, so a follow-up turn still knows what was attached.
+     */
+    attachments: (0, pg_core_1.jsonb)('attachments').$type(),
+    /**
+     * The skills that were in force for this turn — attached by the person
+     * *and* the workspace's always-on ones. Null on an assistant turn and
+     * on a user turn that ran with none.
+     *
+     * A **snapshot** (name, title, source), not ids: a skill can be renamed
+     * or deleted, and a thread read months later still has to be able to
+     * say what shaped the answer. It is also what the transcript renders as
+     * chips, which is the only way a person ever learns, after the fact,
+     * that an answer was written under instructions they did not see.
+     *
+     * Its own column rather than a content block, for the same two reasons
+     * `attachments` is: no adapter needs to switch on it, and recovering it
+     * by parsing a text block works until someone types the prefix.
+     */
+    skills: (0, pg_core_1.jsonb)('skills').$type(),
+    /** Which model produced an assistant turn; null on a user turn. */
+    model: (0, pg_core_1.text)('model'),
+    /** Which registered provider served it; null on a user turn. */
+    provider: (0, pg_core_1.text)('provider'),
+    /** Why the run ended, on the final assistant turn. */
+    stopReason: (0, pg_core_1.text)('stop_reason'),
+    /** Tokens billed as input across the run. */
+    inputTokens: (0, pg_core_1.integer)('input_tokens'),
+    /** Tokens the model generated across the run. */
+    outputTokens: (0, pg_core_1.integer)('output_tokens'),
+    /**
+     * Monotonic position within the thread. Explicit rather than inferred
+     * from `createdAt`: two turns of one run can land inside the same
+     * millisecond, and a transcript that renders out of order is worse
+     * than one that renders slowly.
+     */
+    position: (0, pg_core_1.integer)('position').notNull(),
+    /** Row creation timestamp. */
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow()
+}, (table) => [
+    // The transcript read: one thread's turns, in order.
+    (0, pg_core_1.index)('copilot_messages_thread_idx').on(table.conversationId, table.position)
+]);

package/dist/lib/chat/infrastructure/schema/proposals.d.ts

@@ -0,0 +1,328 @@
+/**
+ * **The accept boundary** — one row per change the copilot proposed
+ * ([ADR-0005](../../../../../../docs/adr/0005-copilot-authority-model.md) §5).
+ *
+ * Every mutating tool writes here first and a human decides; a workspace that
+ * opted a tool into auto-apply still gets the row, accepted in the same breath.
+ * That is what makes a direct apply "undoable, never invisible" rather than a
+ * write with no paper trail — the row records what was proposed, by which run,
+ * on whose behalf, and who decided.
+ *
+ * `target` and `patch` are opaque jsonb on purpose: their shape belongs to the
+ * applier that declared the `kind`, and teaching this table about content
+ * entries would make the copilot the thing that changes when content does.
+ */
+export declare const copilotProposals: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "copilot_proposals";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        conversationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "conversation_id";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toolCallId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tool_call_id";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toolName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tool_name";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        target: import("drizzle-orm/pg-core").PgColumn<{
+            name: "target";
+            tableName: "copilot_proposals";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        patch: import("drizzle-orm/pg-core").PgColumn<{
+            name: "patch";
+            tableName: "copilot_proposals";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        summary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "summary";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        changes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "changes";
+            tableName: "copilot_proposals";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        decidedBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "decided_by";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        decidedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "decided_at";
+            tableName: "copilot_proposals";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        result: import("drizzle-orm/pg-core").PgColumn<{
+            name: "result";
+            tableName: "copilot_proposals";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "copilot_proposals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "copilot_proposals";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=proposals.d.ts.map

package/dist/lib/chat/infrastructure/schema/proposals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposals.d.ts","sourceRoot":"","sources":["../../../../../src/lib/chat/infrastructure/schema/proposals.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0E5B,CAAC"}