@voyant-travel/relationships 0.119.2

package/dist/schema-activities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-activities.d.ts","sourceRoot":"","sources":["../src/schema-activities.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBtB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBzB,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBhC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAUgB,MAAM;uBAAS,MAAM;;;;;;;;;;;;;;uBAArB,MAAM;uBAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASvE,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC7B,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,OAAO,UAAU,CAAC,YAAY,CAAA;AACrD,MAAM,MAAM,WAAW,GAAG,OAAO,UAAU,CAAC,YAAY,CAAA;AACxD,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC/D,MAAM,MAAM,mBAAmB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAA;AAC1E,MAAM,MAAM,sBAAsB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAA;AAC7E,MAAM,MAAM,qBAAqB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAA;AAC9E,MAAM,MAAM,wBAAwB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAA;AACjF,MAAM,MAAM,gBAAgB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAA;AACpE,MAAM,MAAM,mBAAmB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAA"}

package/dist/schema-activities.js

@@ -0,0 +1,92 @@
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, date, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { people } from "./schema-accounts.js";
+import { activityLinkRoleEnum, activityStatusEnum, activityTypeEnum, customFieldTypeEnum, entityTypeEnum, } from "./schema-shared.js";
+export const activities = pgTable("activities", {
+    id: typeId("activities"),
+    subject: text("subject").notNull(),
+    type: activityTypeEnum("type").notNull(),
+    ownerId: text("owner_id"),
+    status: activityStatusEnum("status").notNull().default("planned"),
+    dueAt: timestamp("due_at", { withTimezone: true }),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    location: text("location"),
+    description: text("description"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_activities_owner").on(table.ownerId),
+    index("idx_activities_status").on(table.status),
+    index("idx_activities_type").on(table.type),
+    index("idx_activities_owner_updated").on(table.ownerId, table.updatedAt),
+    index("idx_activities_status_updated").on(table.status, table.updatedAt),
+    index("idx_activities_type_updated").on(table.type, table.updatedAt),
+]);
+export const activityLinks = pgTable("activity_links", {
+    id: typeId("activity_links"),
+    activityId: typeIdRef("activity_id")
+        .notNull()
+        .references(() => activities.id, { onDelete: "cascade" }),
+    entityType: entityTypeEnum("entity_type").notNull(),
+    entityId: text("entity_id").notNull(),
+    role: activityLinkRoleEnum("role").notNull().default("related"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_activity_links_activity").on(table.activityId),
+    index("idx_activity_links_activity_role").on(table.activityId, table.role, table.createdAt),
+    index("idx_activity_links_entity").on(table.entityType, table.entityId),
+]);
+export const activityParticipants = pgTable("activity_participants", {
+    id: typeId("activity_participants"),
+    activityId: typeIdRef("activity_id")
+        .notNull()
+        .references(() => activities.id, { onDelete: "cascade" }),
+    personId: typeIdRef("person_id")
+        .notNull()
+        .references(() => people.id, { onDelete: "cascade" }),
+    isPrimary: boolean("is_primary").notNull().default(false),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_activity_participants_activity").on(table.activityId),
+    index("idx_activity_participants_activity_primary").on(table.activityId, table.isPrimary, table.createdAt),
+    uniqueIndex("uidx_activity_participants_unique").on(table.activityId, table.personId),
+]);
+export const customFieldDefinitions = pgTable("custom_field_definitions", {
+    id: typeId("custom_field_definitions"),
+    entityType: entityTypeEnum("entity_type").notNull(),
+    key: text("key").notNull(),
+    label: text("label").notNull(),
+    fieldType: customFieldTypeEnum("field_type").notNull(),
+    isRequired: boolean("is_required").notNull().default(false),
+    isSearchable: boolean("is_searchable").notNull().default(false),
+    options: jsonb("options").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_custom_field_definitions_entity").on(table.entityType),
+    index("idx_custom_field_definitions_entity_label").on(table.entityType, table.label),
+    uniqueIndex("uidx_custom_field_definitions_key").on(table.entityType, table.key),
+]);
+export const customFieldValues = pgTable("custom_field_values", {
+    id: typeId("custom_field_values"),
+    definitionId: typeIdRef("definition_id")
+        .notNull()
+        .references(() => customFieldDefinitions.id, { onDelete: "cascade" }),
+    entityType: entityTypeEnum("entity_type").notNull(),
+    entityId: text("entity_id").notNull(),
+    textValue: text("text_value"),
+    numberValue: integer("number_value"),
+    dateValue: date("date_value"),
+    booleanValue: boolean("boolean_value"),
+    monetaryValueCents: integer("monetary_value_cents"),
+    currencyCode: text("currency_code"),
+    jsonValue: jsonb("json_value").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_custom_field_values_entity").on(table.entityType, table.entityId),
+    index("idx_custom_field_values_entity_type_updated").on(table.entityType, table.updatedAt),
+    index("idx_custom_field_values_entity_updated").on(table.entityType, table.entityId, table.updatedAt),
+    index("idx_custom_field_values_definition_updated").on(table.definitionId, table.updatedAt),
+    uniqueIndex("uidx_custom_field_values_unique").on(table.definitionId, table.entityType, table.entityId),
+]);

package/dist/schema-relations.d.ts

@@ -0,0 +1,47 @@
+export declare const organizationsRelations: import("drizzle-orm").Relations<"organizations", {
+    people: import("drizzle-orm").Many<"people">;
+    notes: import("drizzle-orm").Many<"organization_notes">;
+    communications: import("drizzle-orm").Many<"communication_log">;
+}>;
+export declare const peopleRelations: import("drizzle-orm").Relations<"people", {
+    organization: import("drizzle-orm").One<"organizations", false>;
+    activityParticipants: import("drizzle-orm").Many<"activity_participants">;
+    notes: import("drizzle-orm").Many<"person_notes">;
+    communications: import("drizzle-orm").Many<"communication_log">;
+    segmentMemberships: import("drizzle-orm").Many<"segment_members">;
+}>;
+export declare const activitiesRelations: import("drizzle-orm").Relations<"activities", {
+    links: import("drizzle-orm").Many<"activity_links">;
+    participants: import("drizzle-orm").Many<"activity_participants">;
+}>;
+export declare const activityLinksRelations: import("drizzle-orm").Relations<"activity_links", {
+    activity: import("drizzle-orm").One<"activities", true>;
+}>;
+export declare const activityParticipantsRelations: import("drizzle-orm").Relations<"activity_participants", {
+    activity: import("drizzle-orm").One<"activities", true>;
+    person: import("drizzle-orm").One<"people", true>;
+}>;
+export declare const customFieldDefinitionsRelations: import("drizzle-orm").Relations<"custom_field_definitions", {
+    values: import("drizzle-orm").Many<"custom_field_values">;
+}>;
+export declare const customFieldValuesRelations: import("drizzle-orm").Relations<"custom_field_values", {
+    definition: import("drizzle-orm").One<"custom_field_definitions", true>;
+}>;
+export declare const personNotesRelations: import("drizzle-orm").Relations<"person_notes", {
+    person: import("drizzle-orm").One<"people", true>;
+}>;
+export declare const organizationNotesRelations: import("drizzle-orm").Relations<"organization_notes", {
+    organization: import("drizzle-orm").One<"organizations", true>;
+}>;
+export declare const communicationLogRelations: import("drizzle-orm").Relations<"communication_log", {
+    person: import("drizzle-orm").One<"people", true>;
+    organization: import("drizzle-orm").One<"organizations", false>;
+}>;
+export declare const segmentsRelations: import("drizzle-orm").Relations<"segments", {
+    members: import("drizzle-orm").Many<"segment_members">;
+}>;
+export declare const segmentMembersRelations: import("drizzle-orm").Relations<"segment_members", {
+    segment: import("drizzle-orm").One<"segments", true>;
+    person: import("drizzle-orm").One<"people", true>;
+}>;
+//# sourceMappingURL=schema-relations.d.ts.map

package/dist/schema-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-relations.d.ts","sourceRoot":"","sources":["../src/schema-relations.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,sBAAsB;;;;EAIhC,CAAA;AAEH,eAAO,MAAM,eAAe;;;;;;EASzB,CAAA;AAEH,eAAO,MAAM,mBAAmB;;;EAG7B,CAAA;AAEH,eAAO,MAAM,sBAAsB;;EAKhC,CAAA;AAEH,eAAO,MAAM,6BAA6B;;;EASvC,CAAA;AAEH,eAAO,MAAM,+BAA+B;;EAEzC,CAAA;AAEH,eAAO,MAAM,0BAA0B;;EAKpC,CAAA;AAEH,eAAO,MAAM,oBAAoB;;EAE9B,CAAA;AAEH,eAAO,MAAM,0BAA0B;;EAKpC,CAAA;AAEH,eAAO,MAAM,yBAAyB;;;EAMnC,CAAA;AAEH,eAAO,MAAM,iBAAiB;;EAE3B,CAAA;AAEH,eAAO,MAAM,uBAAuB;;;EAGjC,CAAA"}

package/dist/schema-relations.js

@@ -0,0 +1,70 @@
+import { relations } from "drizzle-orm";
+import { communicationLog, organizationNotes, organizations, people, personNotes, segmentMembers, segments, } from "./schema-accounts.js";
+import { activities, activityLinks, activityParticipants, customFieldDefinitions, customFieldValues, } from "./schema-activities.js";
+export const organizationsRelations = relations(organizations, ({ many }) => ({
+    people: many(people),
+    notes: many(organizationNotes),
+    communications: many(communicationLog),
+}));
+export const peopleRelations = relations(people, ({ one, many }) => ({
+    organization: one(organizations, {
+        fields: [people.organizationId],
+        references: [organizations.id],
+    }),
+    activityParticipants: many(activityParticipants),
+    notes: many(personNotes),
+    communications: many(communicationLog),
+    segmentMemberships: many(segmentMembers),
+}));
+export const activitiesRelations = relations(activities, ({ many }) => ({
+    links: many(activityLinks),
+    participants: many(activityParticipants),
+}));
+export const activityLinksRelations = relations(activityLinks, ({ one }) => ({
+    activity: one(activities, {
+        fields: [activityLinks.activityId],
+        references: [activities.id],
+    }),
+}));
+export const activityParticipantsRelations = relations(activityParticipants, ({ one }) => ({
+    activity: one(activities, {
+        fields: [activityParticipants.activityId],
+        references: [activities.id],
+    }),
+    person: one(people, {
+        fields: [activityParticipants.personId],
+        references: [people.id],
+    }),
+}));
+export const customFieldDefinitionsRelations = relations(customFieldDefinitions, ({ many }) => ({
+    values: many(customFieldValues),
+}));
+export const customFieldValuesRelations = relations(customFieldValues, ({ one }) => ({
+    definition: one(customFieldDefinitions, {
+        fields: [customFieldValues.definitionId],
+        references: [customFieldDefinitions.id],
+    }),
+}));
+export const personNotesRelations = relations(personNotes, ({ one }) => ({
+    person: one(people, { fields: [personNotes.personId], references: [people.id] }),
+}));
+export const organizationNotesRelations = relations(organizationNotes, ({ one }) => ({
+    organization: one(organizations, {
+        fields: [organizationNotes.organizationId],
+        references: [organizations.id],
+    }),
+}));
+export const communicationLogRelations = relations(communicationLog, ({ one }) => ({
+    person: one(people, { fields: [communicationLog.personId], references: [people.id] }),
+    organization: one(organizations, {
+        fields: [communicationLog.organizationId],
+        references: [organizations.id],
+    }),
+}));
+export const segmentsRelations = relations(segments, ({ many }) => ({
+    members: many(segmentMembers),
+}));
+export const segmentMembersRelations = relations(segmentMembers, ({ one }) => ({
+    segment: one(segments, { fields: [segmentMembers.segmentId], references: [segments.id] }),
+    person: one(people, { fields: [segmentMembers.personId], references: [people.id] }),
+}));

package/dist/schema-shared.d.ts

@@ -0,0 +1,10 @@
+export declare const entityTypeEnum: import("drizzle-orm/pg-core").PgEnum<["organization", "person", "quote", "activity"]>;
+export declare const relationTypeEnum: import("drizzle-orm/pg-core").PgEnum<["client", "partner", "supplier", "other"]>;
+export declare const communicationChannelEnum: import("drizzle-orm/pg-core").PgEnum<["email", "phone", "whatsapp", "sms", "meeting", "other"]>;
+export declare const communicationDirectionEnum: import("drizzle-orm/pg-core").PgEnum<["inbound", "outbound"]>;
+export declare const recordStatusEnum: import("drizzle-orm/pg-core").PgEnum<["active", "inactive", "archived"]>;
+export declare const activityTypeEnum: import("drizzle-orm/pg-core").PgEnum<["call", "email", "meeting", "task", "follow_up", "note"]>;
+export declare const activityStatusEnum: import("drizzle-orm/pg-core").PgEnum<["planned", "done", "cancelled"]>;
+export declare const activityLinkRoleEnum: import("drizzle-orm/pg-core").PgEnum<["primary", "related"]>;
+export declare const customFieldTypeEnum: import("drizzle-orm/pg-core").PgEnum<["varchar", "text", "double", "monetary", "date", "boolean", "enum", "set", "json", "address", "phone"]>;
+//# sourceMappingURL=schema-shared.d.ts.map

package/dist/schema-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-shared.d.ts","sourceRoot":"","sources":["../src/schema-shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,uFAAyE,CAAA;AAEpG,eAAO,MAAM,gBAAgB,kFAAsE,CAAA;AAEnG,eAAO,MAAM,wBAAwB,iGAOnC,CAAA;AAEF,eAAO,MAAM,0BAA0B,+DAA6D,CAAA;AAEpG,eAAO,MAAM,gBAAgB,0EAA8D,CAAA;AAE3F,eAAO,MAAM,gBAAgB,iGAO3B,CAAA;AAEF,eAAO,MAAM,kBAAkB,wEAA8D,CAAA;AAE7F,eAAO,MAAM,oBAAoB,8DAAuD,CAAA;AAExF,eAAO,MAAM,mBAAmB,+IAY9B,CAAA"}

package/dist/schema-shared.js

@@ -0,0 +1,36 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+export const entityTypeEnum = pgEnum("entity_type", ["organization", "person", "quote", "activity"]);
+export const relationTypeEnum = pgEnum("relation_type", ["client", "partner", "supplier", "other"]);
+export const communicationChannelEnum = pgEnum("communication_channel", [
+    "email",
+    "phone",
+    "whatsapp",
+    "sms",
+    "meeting",
+    "other",
+]);
+export const communicationDirectionEnum = pgEnum("communication_direction", ["inbound", "outbound"]);
+export const recordStatusEnum = pgEnum("record_status", ["active", "inactive", "archived"]);
+export const activityTypeEnum = pgEnum("activity_type", [
+    "call",
+    "email",
+    "meeting",
+    "task",
+    "follow_up",
+    "note",
+]);
+export const activityStatusEnum = pgEnum("activity_status", ["planned", "done", "cancelled"]);
+export const activityLinkRoleEnum = pgEnum("activity_link_role", ["primary", "related"]);
+export const customFieldTypeEnum = pgEnum("custom_field_type", [
+    "varchar",
+    "text",
+    "double",
+    "monetary",
+    "date",
+    "boolean",
+    "enum",
+    "set",
+    "json",
+    "address",
+    "phone",
+]);

package/dist/schema-signals.d.ts

@@ -0,0 +1,324 @@
+/**
+ * Customer signals — lighter than `quotes` (no deal value or
+ * stages), heavier than `segments` (lifecycle + assignment). Records
+ * "person X expressed interest in product/departure Y from source Z,
+ * status pending". The most common use cases:
+ *
+ *   - Notify-availability ("ping me when this departure opens up")
+ *   - Wishlist / saved trips
+ *   - Inquiry captured by an operator (phone call, web form)
+ *   - Request-offer pre-pipeline that may or may not become a booking
+ *   - Abandoned-cart recovery
+ *
+ * Cross-module IDs (`productId`, `optionUnitId`, `resolvedBookingId`)
+ * are intentionally plain `text()` columns rather than FK references
+ * — voyant's project-wide rule is that cross-module FKs go through
+ * link tables or stay loose. The signal is owned by CRM; products
+ * and bookings reference its id, not the other way around.
+ */
+export declare const customerSignalKindEnum: import("drizzle-orm/pg-core").PgEnum<["wishlist", "notify", "inquiry", "request_offer", "referral"]>;
+export declare const customerSignalSourceEnum: import("drizzle-orm/pg-core").PgEnum<["form", "phone", "admin", "abandoned_cart", "website", "booking"]>;
+export declare const customerSignalStatusEnum: import("drizzle-orm/pg-core").PgEnum<["new", "contacted", "qualified", "converted", "lost", "expired"]>;
+export declare const customerSignals: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "customer_signals";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "customer_signals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        personId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        optionUnitId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "option_unit_id";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "customer_signals";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "notify" | "wishlist" | "inquiry" | "request_offer" | "referral";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["wishlist", "notify", "inquiry", "request_offer", "referral"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "customer_signals";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "admin" | "form" | "phone" | "abandoned_cart" | "website" | "booking";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["form", "phone", "admin", "abandoned_cart", "website", "booking"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "customer_signals";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "expired" | "new" | "contacted" | "qualified" | "converted" | "lost";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["new", "contacted", "qualified", "converted", "lost", "expired"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        priority: import("drizzle-orm/pg-core").PgColumn<{
+            name: "priority";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        tags: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tags";
+            tableName: "customer_signals";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        assignedToUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "assigned_to_user_id";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        followUpAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "follow_up_at";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        resolvedBookingId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "resolved_booking_id";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        sourceSubmissionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_submission_id";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "customer_signals";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "customer_signals";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "customer_signals";
+            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";
+}>;
+export type CustomerSignal = typeof customerSignals.$inferSelect;
+export type NewCustomerSignal = typeof customerSignals.$inferInsert;
+//# sourceMappingURL=schema-signals.d.ts.map

package/dist/schema-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-signals.d.ts","sourceRoot":"","sources":["../src/schema-signals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH,eAAO,MAAM,sBAAsB,sGAMjC,CAAA;AAEF,eAAO,MAAM,wBAAwB,0GAOnC,CAAA;AAEF,eAAO,MAAM,wBAAwB,yGAOnC,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C3B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,eAAe,CAAC,YAAY,CAAA;AAChE,MAAM,MAAM,iBAAiB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAA"}