@voyantjs/crm 0.105.1 → 0.106.0

package/dist/routes/accounts.d.ts

@@ -162,6 +162,52 @@ export declare const accountRoutes: import("hono/hono-base").HonoBase<Env, {
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
+} & {
+    "/organizations/:id/merge": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    legalName: string | null;
+                    website: string | null;
+                    taxId: string | null;
+                    industry: string | null;
+                    relation: "partner" | "supplier" | "other" | "client" | null;
+                    ownerId: string | null;
+                    defaultCurrency: string | null;
+                    preferredLanguage: string | null;
+                    paymentTerms: number | null;
+                    status: "active" | "inactive" | "archived";
+                    source: string | null;
+                    sourceRef: string | null;
+                    tags: string[];
+                    notes: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                    archivedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 } & {
     "/organizations/:id": {
         $delete: {
@@ -654,6 +700,65 @@ export declare const accountRoutes: import("hono/hono-base").HonoBase<Env, {
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
+} & {
+    "/people/:id/merge": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    organizationId: string | null;
+                    firstName: string;
+                    middleName: string | null;
+                    lastName: string;
+                    gender: string | null;
+                    jobTitle: string | null;
+                    relation: "partner" | "supplier" | "other" | "client" | null;
+                    preferredLanguage: string | null;
+                    preferredCurrency: string | null;
+                    ownerId: string | null;
+                    status: "active" | "inactive" | "archived";
+                    source: string | null;
+                    sourceRef: string | null;
+                    tags: string[];
+                    dateOfBirth: string | null;
+                    notes: string | null;
+                    accessibilityEncrypted: {
+                        enc: string;
+                    } | null;
+                    dietaryEncrypted: {
+                        enc: string;
+                    } | null;
+                    loyaltyEncrypted: {
+                        enc: string;
+                    } | null;
+                    insuranceEncrypted: {
+                        enc: string;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                    archivedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 } & {
     "/people/:id": {
         $delete: {

package/dist/routes/accounts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/routes/accounts.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAsBjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAKD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8TtB,CAAA"}
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/routes/accounts.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AA0BjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAYD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAgVtB,CAAA"}

package/dist/routes/accounts.js

@@ -1,10 +1,17 @@
 import { idempotencyKey, parseJsonBody, parseQuery, requireUserId } from "@voyantjs/hono";
 import { insertAddressSchema, insertContactPointSchema, updateAddressSchema, updateContactPointSchema, } from "@voyantjs/identity/validation";
 import { Hono } from "hono";
+import { CrmMergeError } from "../service/accounts-merge.js";
 import { crmService } from "../service/index.js";
-import { communicationListQuerySchema, insertCommunicationLogSchema, insertOrganizationNoteSchema, insertOrganizationSchema, insertPersonNoteSchema, insertPersonPaymentMethodSchema, insertPersonSchema, insertSegmentSchema, organizationListQuerySchema, personListQuerySchema, updateOrganizationNoteSchema, updateOrganizationSchema, updatePersonNoteSchema, updatePersonPaymentMethodSchema, updatePersonSchema, } from "../validation.js";
+import { communicationListQuerySchema, insertCommunicationLogSchema, insertOrganizationNoteSchema, insertOrganizationSchema, insertPersonNoteSchema, insertPersonPaymentMethodSchema, insertPersonSchema, insertSegmentSchema, mergeOrganizationSchema, mergePersonSchema, organizationListQuerySchema, personListQuerySchema, updateOrganizationNoteSchema, updateOrganizationSchema, updatePersonNoteSchema, updatePersonPaymentMethodSchema, updatePersonSchema, } from "../validation.js";
 const organizationEntity = "organization";
 const personEntity = "person";
+function mergeErrorResponse(c, error) {
+    if (error instanceof CrmMergeError) {
+        return c.json({ error: error.message }, error.status);
+    }
+    throw error;
+}
 export const accountRoutes = new Hono()
     // Organizations
     .get("/organizations", async (c) => {
@@ -27,6 +34,16 @@ export const accountRoutes = new Hono()
     if (!row)
         return c.json({ error: "Organization not found" }, 404);
     return c.json({ data: row });
+})
+    .post("/organizations/:id/merge", async (c) => {
+    try {
+        const body = await parseJsonBody(c, mergeOrganizationSchema);
+        const row = await crmService.mergeOrganization(c.get("db"), c.req.param("id"), body.mergeId);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        return mergeErrorResponse(c, error);
+    }
 })
     .delete("/organizations/:id", async (c) => {
     const row = await crmService.deleteOrganization(c.get("db"), c.req.param("id"));
@@ -100,6 +117,16 @@ export const accountRoutes = new Hono()
     if (!row)
         return c.json({ error: "Person not found" }, 404);
     return c.json({ data: row });
+})
+    .post("/people/:id/merge", async (c) => {
+    try {
+        const body = await parseJsonBody(c, mergePersonSchema);
+        const row = await crmService.mergePerson(c.get("db"), c.req.param("id"), body.mergeId);
+        return c.json({ data: row });
+    }
+    catch (error) {
+        return mergeErrorResponse(c, error);
+    }
 })
     .delete("/people/:id", async (c) => {
     const row = await crmService.deletePerson(c.get("db"), c.req.param("id"));

package/dist/routes/index.d.ts

@@ -162,6 +162,52 @@ export declare const crmRoutes: import("hono/hono-base").HonoBase<Env, import("h
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
+} & {
+    "/organizations/:id/merge": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    legalName: string | null;
+                    website: string | null;
+                    taxId: string | null;
+                    industry: string | null;
+                    relation: "partner" | "supplier" | "other" | "client" | null;
+                    ownerId: string | null;
+                    defaultCurrency: string | null;
+                    preferredLanguage: string | null;
+                    paymentTerms: number | null;
+                    status: "active" | "inactive" | "archived";
+                    source: string | null;
+                    sourceRef: string | null;
+                    tags: string[];
+                    notes: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                    archivedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 } & {
     "/organizations/:id": {
         $delete: {
@@ -654,6 +700,65 @@ export declare const crmRoutes: import("hono/hono-base").HonoBase<Env, import("h
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
+} & {
+    "/people/:id/merge": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    organizationId: string | null;
+                    firstName: string;
+                    middleName: string | null;
+                    lastName: string;
+                    gender: string | null;
+                    jobTitle: string | null;
+                    relation: "partner" | "supplier" | "other" | "client" | null;
+                    preferredLanguage: string | null;
+                    preferredCurrency: string | null;
+                    ownerId: string | null;
+                    status: "active" | "inactive" | "archived";
+                    source: string | null;
+                    sourceRef: string | null;
+                    tags: string[];
+                    dateOfBirth: string | null;
+                    notes: string | null;
+                    accessibilityEncrypted: {
+                        enc: string;
+                    } | null;
+                    dietaryEncrypted: {
+                        enc: string;
+                    } | null;
+                    loyaltyEncrypted: {
+                        enc: string;
+                    } | null;
+                    insuranceEncrypted: {
+                        enc: string;
+                    } | null;
+                    createdAt: string;
+                    updatedAt: string;
+                    archivedAt: string | null;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
 } & {
     "/people/:id": {
         $delete: {

package/dist/routes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAajE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASU,CAAA;AAEhC,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAajE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASU,CAAA;AAEhC,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA"}

package/dist/service/accounts-merge.d.ts

@@ -0,0 +1,63 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export declare class CrmMergeError extends Error {
+    readonly status: 400 | 404;
+    constructor(message: string, status: 400 | 404);
+}
+export declare const accountMergeService: {
+    mergePerson(db: PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        organizationId: string | null;
+        firstName: string;
+        middleName: string | null;
+        lastName: string;
+        gender: string | null;
+        jobTitle: string | null;
+        relation: "partner" | "supplier" | "other" | "client" | null;
+        preferredLanguage: string | null;
+        preferredCurrency: string | null;
+        ownerId: string | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        dateOfBirth: string | null;
+        notes: string | null;
+        accessibilityEncrypted: {
+            enc: string;
+        } | null;
+        dietaryEncrypted: {
+            enc: string;
+        } | null;
+        loyaltyEncrypted: {
+            enc: string;
+        } | null;
+        insuranceEncrypted: {
+            enc: string;
+        } | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
+    mergeOrganization(db: PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        name: string;
+        legalName: string | null;
+        website: string | null;
+        taxId: string | null;
+        industry: string | null;
+        relation: "partner" | "supplier" | "other" | "client" | null;
+        ownerId: string | null;
+        defaultCurrency: string | null;
+        preferredLanguage: string | null;
+        paymentTerms: number | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
+};
+//# sourceMappingURL=accounts-merge.d.ts.map

package/dist/service/accounts-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts-merge.d.ts","sourceRoot":"","sources":["../../src/service/accounts-merge.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAqBjE,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAA;gBAEd,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG;CAK/C;AA4TD,eAAO,MAAM,mBAAmB;oBACR,kBAAkB,UAAU,MAAM,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAmI7C,kBAAkB,UAAU,MAAM,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;CAoFhF,CAAA"}

package/dist/service/accounts-merge.js

@@ -0,0 +1,366 @@
+import { identityAddresses, identityContactPoints, identityNamedContacts, } from "@voyantjs/identity/schema";
+import { and, eq, inArray, ne, or, sql } from "drizzle-orm";
+import { activityLinks, activityParticipants, communicationLog, customerSignals, customFieldValues, opportunities, opportunityParticipants, organizationNotes, organizations, people, personDocuments, personNotes, personPaymentMethods, personRelationships, segmentMembers, } from "../schema.js";
+import { hydratePeople, organizationEntityType, personEntityType } from "./accounts-shared.js";
+export class CrmMergeError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = "CrmMergeError";
+        this.status = status;
+    }
+}
+const OPTIONAL_PERSON_REFERENCES = [
+    { table: "bookings", column: "person_id" },
+    { table: "booking_travelers", column: "person_id" },
+    { table: "booking_staff_assignments", column: "person_id" },
+    { table: "offers", column: "person_id" },
+    { table: "offer_participants", column: "person_id" },
+    { table: "offer_contact_assignments", column: "person_id" },
+    { table: "offer_staff_assignments", column: "person_id" },
+    { table: "orders", column: "person_id" },
+    { table: "order_participants", column: "person_id" },
+    { table: "order_contact_assignments", column: "person_id" },
+    { table: "order_staff_assignments", column: "person_id" },
+    { table: "order_terms", column: "accepted_by" },
+    { table: "invoices", column: "person_id" },
+    { table: "vouchers", column: "issued_to_person_id" },
+    { table: "payment_instruments", column: "person_id" },
+    { table: "payment_sessions", column: "payer_person_id" },
+    { table: "contracts", column: "person_id" },
+    { table: "contract_signatures", column: "person_id" },
+    { table: "policy_acceptances", column: "person_id" },
+    { table: "policy_acceptances", column: "accepted_by" },
+    { table: "notification_deliveries", column: "person_id" },
+    { table: "notification_reminder_runs", column: "person_id" },
+];
+const OPTIONAL_ORGANIZATION_REFERENCES = [
+    { table: "bookings", column: "organization_id" },
+    { table: "offers", column: "organization_id" },
+    { table: "orders", column: "organization_id" },
+    { table: "invoices", column: "organization_id" },
+    { table: "vouchers", column: "issued_to_organization_id" },
+    { table: "payment_instruments", column: "organization_id" },
+    { table: "payment_sessions", column: "payer_organization_id" },
+    { table: "contracts", column: "organization_id" },
+    { table: "policy_assignments", column: "organization_id" },
+    { table: "notification_deliveries", column: "organization_id" },
+    { table: "notification_reminder_runs", column: "organization_id" },
+];
+const OPTIONAL_PERSON_ENTITY_TARGET_REFERENCES = [
+    { table: "notification_deliveries", entityType: "person" },
+];
+const OPTIONAL_ORGANIZATION_ENTITY_TARGET_REFERENCES = [
+    { table: "notification_deliveries", entityType: "organization" },
+];
+function quoteIdentifier(identifier) {
+    return `"${identifier.replaceAll('"', '""')}"`;
+}
+function mergeTags(keepTags, mergeTags) {
+    return [...new Set([...(keepTags ?? []), ...(mergeTags ?? [])])];
+}
+function backfill(keep, merge, keys) {
+    const patch = {};
+    for (const key of keys) {
+        const keepValue = keep[key];
+        const mergeValue = merge[key];
+        if ((keepValue === null || keepValue === undefined || keepValue === "") &&
+            mergeValue !== null &&
+            mergeValue !== undefined &&
+            mergeValue !== "") {
+            patch[key] = mergeValue;
+        }
+    }
+    return patch;
+}
+async function tableHasColumn(db, table, column) {
+    const rows = await db.execute(sql `
+    SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.columns
+      WHERE table_schema = 'public'
+        AND table_name = ${table}
+        AND column_name = ${column}
+    ) AS "exists"
+  `);
+    return Boolean(rows[0]?.exists);
+}
+async function updateOptionalReference(db, reference, keepId, mergeId) {
+    if (!(await tableHasColumn(db, reference.table, reference.column)))
+        return;
+    await db.execute(sql `
+    UPDATE ${sql.raw(quoteIdentifier(reference.table))}
+    SET ${sql.raw(quoteIdentifier(reference.column))} = ${keepId}
+    WHERE ${sql.raw(quoteIdentifier(reference.column))} = ${mergeId}
+  `);
+}
+async function updateOptionalReferences(db, references, keepId, mergeId) {
+    for (const reference of references) {
+        await updateOptionalReference(db, reference, keepId, mergeId);
+    }
+}
+async function updateOptionalEntityTargetReference(db, reference, keepId, mergeId) {
+    const hasTargetType = await tableHasColumn(db, reference.table, "target_type");
+    const hasTargetId = await tableHasColumn(db, reference.table, "target_id");
+    if (!hasTargetType || !hasTargetId)
+        return;
+    await db.execute(sql `
+    UPDATE ${sql.raw(quoteIdentifier(reference.table))}
+    SET target_id = ${keepId}
+    WHERE target_type = ${reference.entityType}
+      AND target_id = ${mergeId}
+  `);
+}
+async function updateOptionalEntityTargetReferences(db, references, keepId, mergeId) {
+    for (const reference of references) {
+        await updateOptionalEntityTargetReference(db, reference, keepId, mergeId);
+    }
+}
+async function mergeIdentityRows(db, entityType, keepId, mergeId) {
+    await db.delete(identityContactPoints).where(and(eq(identityContactPoints.entityType, entityType), eq(identityContactPoints.entityId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM identity_contact_points keep_point
+          WHERE keep_point.entity_type = ${entityType}
+            AND keep_point.entity_id = ${keepId}
+            AND keep_point.kind = ${identityContactPoints.kind}
+            AND keep_point.value = ${identityContactPoints.value}
+        )`));
+    await db
+        .update(identityContactPoints)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(identityContactPoints.entityType, entityType), eq(identityContactPoints.entityId, mergeId)));
+    await db
+        .update(identityAddresses)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(identityAddresses.entityType, entityType), eq(identityAddresses.entityId, mergeId)));
+    await db
+        .update(identityNamedContacts)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(identityNamedContacts.entityType, entityType), eq(identityNamedContacts.entityId, mergeId)));
+}
+async function mergeEntityLinks(db, entityType, keepId, mergeId) {
+    await db
+        .update(activityLinks)
+        .set({ entityId: keepId })
+        .where(and(eq(activityLinks.entityType, entityType), eq(activityLinks.entityId, mergeId)));
+    await db.delete(customFieldValues).where(and(eq(customFieldValues.entityType, entityType), eq(customFieldValues.entityId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM custom_field_values keep_value
+          WHERE keep_value.definition_id = ${customFieldValues.definitionId}
+            AND keep_value.entity_type = ${entityType}
+            AND keep_value.entity_id = ${keepId}
+        )`));
+    await db
+        .update(customFieldValues)
+        .set({ entityId: keepId, updatedAt: new Date() })
+        .where(and(eq(customFieldValues.entityType, entityType), eq(customFieldValues.entityId, mergeId)));
+}
+async function dedupePersonJoinTables(db, keepId, mergeId) {
+    await db.delete(opportunityParticipants).where(and(eq(opportunityParticipants.personId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM opportunity_participants keep_participant
+          WHERE keep_participant.opportunity_id = ${opportunityParticipants.opportunityId}
+            AND keep_participant.person_id = ${keepId}
+        )`));
+    await db.delete(activityParticipants).where(and(eq(activityParticipants.personId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM activity_participants keep_participant
+          WHERE keep_participant.activity_id = ${activityParticipants.activityId}
+            AND keep_participant.person_id = ${keepId}
+        )`));
+    await db
+        .delete(personRelationships)
+        .where(or(and(eq(personRelationships.fromPersonId, mergeId), eq(personRelationships.toPersonId, keepId)), and(eq(personRelationships.fromPersonId, keepId), eq(personRelationships.toPersonId, mergeId)), and(eq(personRelationships.fromPersonId, mergeId), eq(personRelationships.toPersonId, mergeId))));
+    await db.delete(personRelationships).where(and(eq(personRelationships.fromPersonId, mergeId), ne(personRelationships.toPersonId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM person_relationships keep_relationship
+          WHERE keep_relationship.from_person_id = ${keepId}
+            AND keep_relationship.to_person_id = ${personRelationships.toPersonId}
+            AND keep_relationship.kind = ${personRelationships.kind}
+        )`));
+    await db.delete(personRelationships).where(and(eq(personRelationships.toPersonId, mergeId), ne(personRelationships.fromPersonId, mergeId), sql `EXISTS (
+          SELECT 1
+          FROM person_relationships keep_relationship
+          WHERE keep_relationship.from_person_id = ${personRelationships.fromPersonId}
+            AND keep_relationship.to_person_id = ${keepId}
+            AND keep_relationship.kind = ${personRelationships.kind}
+        )`));
+}
+export const accountMergeService = {
+    async mergePerson(db, keepId, mergeId) {
+        if (keepId === mergeId) {
+            throw new CrmMergeError("Cannot merge a person into itself", 400);
+        }
+        return db.transaction(async (tx) => {
+            const [keep, merge] = await tx
+                .select()
+                .from(people)
+                .where(inArray(people.id, [keepId, mergeId]))
+                .for("update");
+            const keepPerson = keep?.id === keepId ? keep : merge?.id === keepId ? merge : null;
+            const mergePerson = keep?.id === mergeId ? keep : merge?.id === mergeId ? merge : null;
+            if (!keepPerson)
+                throw new CrmMergeError("Person to keep not found", 404);
+            if (!mergePerson)
+                throw new CrmMergeError("Person to merge not found", 404);
+            await tx
+                .update(people)
+                .set({
+                ...backfill(keepPerson, mergePerson, [
+                    "organizationId",
+                    "middleName",
+                    "gender",
+                    "jobTitle",
+                    "relation",
+                    "preferredLanguage",
+                    "preferredCurrency",
+                    "ownerId",
+                    "source",
+                    "sourceRef",
+                    "dateOfBirth",
+                    "notes",
+                    "accessibilityEncrypted",
+                    "dietaryEncrypted",
+                    "loyaltyEncrypted",
+                    "insuranceEncrypted",
+                ]),
+                tags: mergeTags(keepPerson.tags, mergePerson.tags),
+                updatedAt: new Date(),
+            })
+                .where(eq(people.id, keepId));
+            await dedupePersonJoinTables(tx, keepId, mergeId);
+            await mergeIdentityRows(tx, personEntityType, keepId, mergeId);
+            await mergeEntityLinks(tx, "person", keepId, mergeId);
+            await tx
+                .update(personNotes)
+                .set({ personId: keepId })
+                .where(eq(personNotes.personId, mergeId));
+            await tx
+                .update(personDocuments)
+                .set({ isPrimary: false, updatedAt: new Date() })
+                .where(and(eq(personDocuments.personId, mergeId), eq(personDocuments.isPrimary, true), sql `EXISTS (
+              SELECT 1
+              FROM person_documents keep_document
+              WHERE keep_document.person_id = ${keepId}
+                AND keep_document.type = ${personDocuments.type}
+                AND keep_document.is_primary = true
+            )`));
+            await tx
+                .update(personDocuments)
+                .set({ personId: keepId, updatedAt: new Date() })
+                .where(eq(personDocuments.personId, mergeId));
+            await tx
+                .update(personPaymentMethods)
+                .set({ personId: keepId })
+                .where(eq(personPaymentMethods.personId, mergeId));
+            await tx
+                .update(communicationLog)
+                .set({ personId: keepId })
+                .where(eq(communicationLog.personId, mergeId));
+            await tx
+                .update(opportunities)
+                .set({ personId: keepId, updatedAt: new Date() })
+                .where(eq(opportunities.personId, mergeId));
+            await tx
+                .update(opportunityParticipants)
+                .set({ personId: keepId })
+                .where(eq(opportunityParticipants.personId, mergeId));
+            await tx
+                .update(activityParticipants)
+                .set({ personId: keepId })
+                .where(eq(activityParticipants.personId, mergeId));
+            await tx
+                .update(personRelationships)
+                .set({ fromPersonId: keepId, updatedAt: new Date() })
+                .where(eq(personRelationships.fromPersonId, mergeId));
+            await tx
+                .update(personRelationships)
+                .set({ toPersonId: keepId, updatedAt: new Date() })
+                .where(eq(personRelationships.toPersonId, mergeId));
+            await tx
+                .update(segmentMembers)
+                .set({ personId: keepId })
+                .where(eq(segmentMembers.personId, mergeId));
+            await tx
+                .update(customerSignals)
+                .set({ personId: keepId, updatedAt: new Date() })
+                .where(eq(customerSignals.personId, mergeId));
+            await updateOptionalReferences(tx, OPTIONAL_PERSON_REFERENCES, keepId, mergeId);
+            await updateOptionalEntityTargetReferences(tx, OPTIONAL_PERSON_ENTITY_TARGET_REFERENCES, keepId, mergeId);
+            await tx.delete(people).where(eq(people.id, mergeId));
+            const [row] = await tx.select().from(people).where(eq(people.id, keepId)).limit(1);
+            if (!row)
+                throw new Error("Merged person disappeared");
+            const [hydrated] = await hydratePeople(tx, [row]);
+            return hydrated ?? row;
+        });
+    },
+    async mergeOrganization(db, keepId, mergeId) {
+        if (keepId === mergeId) {
+            throw new CrmMergeError("Cannot merge an organization into itself", 400);
+        }
+        return db.transaction(async (tx) => {
+            const [keep, merge] = await tx
+                .select()
+                .from(organizations)
+                .where(inArray(organizations.id, [keepId, mergeId]))
+                .for("update");
+            const keepOrganization = keep?.id === keepId ? keep : merge?.id === keepId ? merge : null;
+            const mergeOrganization = keep?.id === mergeId ? keep : merge?.id === mergeId ? merge : null;
+            if (!keepOrganization)
+                throw new CrmMergeError("Organization to keep not found", 404);
+            if (!mergeOrganization)
+                throw new CrmMergeError("Organization to merge not found", 404);
+            await tx
+                .update(organizations)
+                .set({
+                ...backfill(keepOrganization, mergeOrganization, [
+                    "legalName",
+                    "website",
+                    "taxId",
+                    "industry",
+                    "relation",
+                    "ownerId",
+                    "defaultCurrency",
+                    "preferredLanguage",
+                    "paymentTerms",
+                    "source",
+                    "sourceRef",
+                    "notes",
+                ]),
+                tags: mergeTags(keepOrganization.tags, mergeOrganization.tags),
+                updatedAt: new Date(),
+            })
+                .where(eq(organizations.id, keepId));
+            await mergeIdentityRows(tx, organizationEntityType, keepId, mergeId);
+            await mergeEntityLinks(tx, "organization", keepId, mergeId);
+            await tx
+                .update(people)
+                .set({ organizationId: keepId, updatedAt: new Date() })
+                .where(eq(people.organizationId, mergeId));
+            await tx
+                .update(organizationNotes)
+                .set({ organizationId: keepId })
+                .where(eq(organizationNotes.organizationId, mergeId));
+            await tx
+                .update(communicationLog)
+                .set({ organizationId: keepId })
+                .where(eq(communicationLog.organizationId, mergeId));
+            await tx
+                .update(opportunities)
+                .set({ organizationId: keepId, updatedAt: new Date() })
+                .where(eq(opportunities.organizationId, mergeId));
+            await updateOptionalReferences(tx, OPTIONAL_ORGANIZATION_REFERENCES, keepId, mergeId);
+            await updateOptionalEntityTargetReferences(tx, OPTIONAL_ORGANIZATION_ENTITY_TARGET_REFERENCES, keepId, mergeId);
+            await tx.delete(organizations).where(eq(organizations.id, mergeId));
+            const [row] = await tx
+                .select()
+                .from(organizations)
+                .where(eq(organizations.id, keepId))
+                .limit(1);
+            if (!row)
+                throw new Error("Merged organization disappeared");
+            return row;
+        });
+    },
+};

package/dist/service/accounts.d.ts

@@ -2,6 +2,61 @@ import { findPersonByContactPoint, personNameFromContact, upsertPersonFromContac
 export declare const accountsService: {
     findPersonByContactPoint: typeof findPersonByContactPoint;
     upsertPersonFromContact: typeof upsertPersonFromContact;
+    mergePerson(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        organizationId: string | null;
+        firstName: string;
+        middleName: string | null;
+        lastName: string;
+        gender: string | null;
+        jobTitle: string | null;
+        relation: "partner" | "supplier" | "other" | "client" | null;
+        preferredLanguage: string | null;
+        preferredCurrency: string | null;
+        ownerId: string | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        dateOfBirth: string | null;
+        notes: string | null;
+        accessibilityEncrypted: {
+            enc: string;
+        } | null;
+        dietaryEncrypted: {
+            enc: string;
+        } | null;
+        loyaltyEncrypted: {
+            enc: string;
+        } | null;
+        insuranceEncrypted: {
+            enc: string;
+        } | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
+    mergeOrganization(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        name: string;
+        legalName: string | null;
+        website: string | null;
+        taxId: string | null;
+        industry: string | null;
+        relation: "partner" | "supplier" | "other" | "client" | null;
+        ownerId: string | null;
+        defaultCurrency: string | null;
+        preferredLanguage: string | null;
+        paymentTerms: number | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
     listPeople(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./accounts-shared.js").PersonListQuery): Promise<{
         data: ({
             id: string;
@@ -1404,6 +1459,7 @@ export declare const accountsService: {
         id: string;
     } | null>;
 };
+export { accountMergeService, CrmMergeError } from "./accounts-merge.js";
 export type { PersonContactInput, UpsertPersonFromContactOptions, } from "./accounts-resolve.js";
 export { findPersonByContactPoint, personNameFromContact, upsertPersonFromContact };
 //# sourceMappingURL=accounts.d.ts.map

package/dist/service/accounts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/service/accounts.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,uBAAuB,CAAA;AAE9B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK3B,CAAA;AAED,YAAY,EACV,kBAAkB,EAClB,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,CAAA"}
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/service/accounts.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,uBAAuB,CAAA;AAE9B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM3B,CAAA;AAED,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxE,YAAY,EACV,kBAAkB,EAClB,8BAA8B,GAC/B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/service/accounts.js

@@ -1,10 +1,13 @@
+import { accountMergeService } from "./accounts-merge.js";
 import { organizationAccountsService } from "./accounts-organizations.js";
 import { peopleAccountsService } from "./accounts-people.js";
 import { findPersonByContactPoint, personNameFromContact, upsertPersonFromContact, } from "./accounts-resolve.js";
 export const accountsService = {
     ...organizationAccountsService,
     ...peopleAccountsService,
+    ...accountMergeService,
     findPersonByContactPoint,
     upsertPersonFromContact,
 };
+export { accountMergeService, CrmMergeError } from "./accounts-merge.js";
 export { findPersonByContactPoint, personNameFromContact, upsertPersonFromContact };

package/dist/service/index.d.ts

@@ -4496,6 +4496,61 @@ export declare const crmService: {
     } | null>;
     findPersonByContactPoint: typeof import("./accounts-resolve.js").findPersonByContactPoint;
     upsertPersonFromContact: typeof import("./accounts-resolve.js").upsertPersonFromContact;
+    mergePerson(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        organizationId: string | null;
+        firstName: string;
+        middleName: string | null;
+        lastName: string;
+        gender: string | null;
+        jobTitle: string | null;
+        relation: "partner" | "supplier" | "other" | "client" | null;
+        preferredLanguage: string | null;
+        preferredCurrency: string | null;
+        ownerId: string | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        dateOfBirth: string | null;
+        notes: string | null;
+        accessibilityEncrypted: {
+            enc: string;
+        } | null;
+        dietaryEncrypted: {
+            enc: string;
+        } | null;
+        loyaltyEncrypted: {
+            enc: string;
+        } | null;
+        insuranceEncrypted: {
+            enc: string;
+        } | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
+    mergeOrganization(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, keepId: string, mergeId: string): Promise<{
+        id: string;
+        name: string;
+        legalName: string | null;
+        website: string | null;
+        taxId: string | null;
+        industry: string | null;
+        relation: "partner" | "supplier" | "other" | "client" | null;
+        ownerId: string | null;
+        defaultCurrency: string | null;
+        preferredLanguage: string | null;
+        paymentTerms: number | null;
+        status: "active" | "inactive" | "archived";
+        source: string | null;
+        sourceRef: string | null;
+        tags: string[];
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        archivedAt: Date | null;
+    }>;
     listPeople(db: import("drizzle-orm/postgres-js").PostgresJsDatabase, query: import("./accounts-shared.js").PersonListQuery): Promise<{
         data: ({
             id: string;

package/dist/service/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/service/index.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqC+gF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA46I,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA3Bn9N,CAAA;AAED,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,mCAAmC,EACnC,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EACV,6BAA6B,EAC7B,sBAAsB,EACtB,2BAA2B,EAC3B,6BAA6B,GAC9B,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/service/index.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqC+gF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA46I,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA3Bn9N,CAAA;AAED,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,mCAAmC,EACnC,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EACV,6BAA6B,EAC7B,sBAAsB,EACtB,2BAA2B,EAC3B,6BAA6B,GAC9B,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/crm",
-  "version": "0.105.1",
+  "version": "0.106.0",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -41,10 +41,10 @@
     "zod": "^4.3.6",
     "@voyantjs/action-ledger": "^0.104.1",
     "@voyantjs/core": "^0.104.1",
-    "@voyantjs/crm-contracts": "^0.104.1",
+    "@voyantjs/crm-contracts": "^0.105.0",
     "@voyantjs/db": "^0.104.2",
     "@voyantjs/hono": "^0.104.1",
-    "@voyantjs/identity": "^0.105.0",
+    "@voyantjs/identity": "^0.106.0",
     "@voyantjs/utils": "^0.104.1"
   },
   "devDependencies": {