@iveri/contracts 0.7.0 → 0.8.0

package/dist/cjs/api/unibox/team.type.d.ts

@@ -0,0 +1,50 @@
+import type { IsoDateTime } from '../../type/iso-date-time.type.js';
+import type { Nullable } from '../../type/nil.type.js';
+import type { Paginated } from '../../type/paginated.type.js';
+import type { UUID } from '../../type/uuid.type.js';
+/**
+ * A group of agents work is routed to — Support, Sales, Billing.
+ *
+ * **A team is not a role and not a membership.** Identity owns who exists and what they may do;
+ * this owns who is expected to answer what. Keeping them apart is what lets an agent be moved
+ * between teams without touching their permissions, which is the operation that actually happens
+ * weekly.
+ *
+ * `memberUserIds` names users in `iveri-identity-api`, so it is a loose reference with no foreign
+ * key. A user removed there leaves a stale id here; Unibox filters those out when resolving a
+ * team rather than pretending it can prevent them.
+ */
+export interface Team {
+    id: UUID;
+    name: string;
+    description: Nullable<string>;
+    /** Identity user ids. Order is not meaningful. */
+    memberUserIds: UUID[];
+    /**
+     * Conversations on these channels are routed to this team when nothing else claims them.
+     *
+     * Empty means the team takes no automatic routing and is assignment-only. Deliberately a list
+     * on the team rather than a team id on the channel: a channel routed to two teams during a
+     * handover period is a real thing customers ask for, and the other direction cannot express it.
+     */
+    channelIds: UUID[];
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+/** `GET /api/v1/teams`. Offset-paged; a tenant has a handful. */
+export type TeamsPage = Paginated<Team>;
+/** `POST /api/v1/teams`. */
+export interface CreateTeamBody {
+    name: string;
+    description?: Nullable<string>;
+    memberUserIds?: Nullable<UUID[]>;
+    channelIds?: Nullable<UUID[]>;
+}
+/** `PATCH /api/v1/teams/:id`. Both id lists replace wholesale; omit to leave alone, `[]` clears. */
+export interface UpdateTeamBody {
+    name?: string;
+    description?: Nullable<string>;
+    memberUserIds?: Nullable<UUID[]>;
+    channelIds?: Nullable<UUID[]>;
+}
+//# sourceMappingURL=team.type.d.ts.map

package/dist/cjs/api/unibox/team.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.type.d.ts","sourceRoot":"","sources":["../../../../src/api/unibox/team.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,IAAI;IACjB,EAAE,EAAE,IAAI,CAAC;IAET,IAAI,EAAE,MAAM,CAAC;IAEb,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE9B,kDAAkD;IAClD,aAAa,EAAE,IAAI,EAAE,CAAC;IAEtB;;;;;;OAMG;IACH,UAAU,EAAE,IAAI,EAAE,CAAC;IAEnB,SAAS,EAAE,WAAW,CAAC;IACvB,SAAS,EAAE,WAAW,CAAC;CAC1B;AAED,iEAAiE;AACjE,MAAM,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;AAExC,4BAA4B;AAC5B,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/B,aAAa,CAAC,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CACjC;AAED,oGAAoG;AACpG,MAAM,WAAW,cAAc;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/B,aAAa,CAAC,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CACjC"}

package/dist/cjs/api/unibox/team.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=team.type.js.map

package/dist/cjs/api/unibox/team.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.type.js","sourceRoot":"","sources":["../../../../src/api/unibox/team.type.ts"],"names":[],"mappings":""}

package/dist/cjs/enum/user-permission.enum.d.ts

@@ -128,7 +128,54 @@ export declare enum UserPermission {
      */
     CONDUIT_DISPATCH_SEND = "conduit:dispatch:send",
     /** Redrive a dead-lettered dispatch, or cancel one still pending. */
-    CONDUIT_DISPATCH_OPERATE = "conduit:dispatch:operate"
+    CONDUIT_DISPATCH_OPERATE = "conduit:dispatch:operate",
+    /** Read connected messaging accounts. Never exposes a channel's ingest secret. */
+    UNIBOX_CHANNEL_READ = "unibox:channel:read",
+    /**
+     * Connect, amend or disconnect a messaging account, and rotate its ingest secret.
+     *
+     * A single manage permission for the same reason as `CONDUIT_CONNECTION_MANAGE`: the
+     * dangerous act is holding the credential that lets anything post messages into a tenant's
+     * inbox, and create/update/delete carry that identically.
+     */
+    UNIBOX_CHANNEL_MANAGE = "unibox:channel:manage",
+    /** Read contacts. Personal data — closer to a data-export permission than a config one. */
+    UNIBOX_CONTACT_READ = "unibox:contact:read",
+    /** Create, amend or delete a contact record. */
+    UNIBOX_CONTACT_MANAGE = "unibox:contact:manage",
+    /**
+     * Read the inbox and every message in it.
+     *
+     * **There is deliberately no separate `unibox:message:read`.** A conversation with its
+     * messages hidden is an empty row, so a permission that granted one without the other would
+     * describe a screen nobody can use — and the reverse would be a way to read a customer's
+     * messages while appearing to have no access to the inbox.
+     */
+    UNIBOX_CONVERSATION_READ = "unibox:conversation:read",
+    /** Change a conversation's status — close, snooze, reopen — and write internal notes. */
+    UNIBOX_CONVERSATION_MANAGE = "unibox:conversation:manage",
+    /**
+     * Assign a conversation to an agent or a team, and take over from the AI.
+     *
+     * Separate from `UNIBOX_CONVERSATION_MANAGE` because assignment decides whose work this is.
+     * A supervisor routing a queue and an agent closing their own conversations are different
+     * jobs, and a tenant that wants only the first to reassign should be able to say so.
+     */
+    UNIBOX_CONVERSATION_ASSIGN = "unibox:conversation:assign",
+    /**
+     * Send a message to a contact.
+     *
+     * The sharpest permission in this service, and the reason there is no `unibox:message:*`
+     * read counterpart. Everything else here moves rows around inside our own database; this one
+     * reaches a real person on their phone, through a paid channel, and cannot be taken back.
+     */
+    UNIBOX_MESSAGE_SEND = "unibox:message:send",
+    UNIBOX_TEAM_READ = "unibox:team:read",
+    /** Create teams and change who is in them. Routing, not permissions — identity owns those. */
+    UNIBOX_TEAM_MANAGE = "unibox:team:manage",
+    UNIBOX_CANNED_REPLY_READ = "unibox:canned-reply:read",
+    /** Author the saved replies every agent in the tenant will send. */
+    UNIBOX_CANNED_REPLY_MANAGE = "unibox:canned-reply:manage"
 }
 /**
  * Every member, for seeding the owner role and validating custom-role input.

package/dist/cjs/enum/user-permission.enum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-permission.enum.d.ts","sourceRoot":"","sources":["../../../src/enum/user-permission.enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,oBAAY,cAAc;IAItB,WAAW,gBAAgB;IAC3B,aAAa,kBAAkB;IAC/B,sFAAsF;IACtF,aAAa,kBAAkB;IAG/B,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAG3B,eAAe,oBAAoB;IACnC,6EAA6E;IAC7E,iBAAiB,sBAAsB;IACvC;;;OAGG;IACH,sBAAsB,2BAA2B;IAGjD,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAG3B,YAAY,iBAAiB;IAC7B,aAAa,kBAAkB;IAC/B,cAAc,mBAAmB;IAKjC,qEAAqE;IACrE,qBAAqB,0BAA0B;IAC/C,uBAAuB,4BAA4B;IACnD,uBAAuB,4BAA4B;IACnD,uBAAuB,4BAA4B;IAGnD;;;;OAIG;IACH,oBAAoB,yBAAyB;IAC7C,sBAAsB,2BAA2B;IAGjD;;;;OAIG;IACH,sBAAsB,2BAA2B;IAGjD,qBAAqB,0BAA0B;IAC/C,yFAAyF;IACzF,uBAAuB,4BAA4B;IAGnD,mEAAmE;IACnE,wBAAwB,6BAA6B;IACrD;;;;;;;OAOG;IACH,0BAA0B,+BAA+B;IAGzD,kBAAkB,uBAAuB;IACzC,2DAA2D;IAC3D,oBAAoB,yBAAyB;IAG7C;;;;;OAKG;IACH,qBAAqB,0BAA0B;IAC/C;;;;;;OAMG;IACH,wBAAwB,6BAA6B;IAGrD,wFAAwF;IACxF,sBAAsB,2BAA2B;IACjD;;;;;;;;OAQG;IACH,wBAAwB,6BAA6B;IAGrD,sEAAsE;IACtE,uBAAuB,4BAA4B;IACnD;;;;;OAKG;IACH,yBAAyB,8BAA8B;IAGvD;;;;;OAKG;IACH,qBAAqB,0BAA0B;IAC/C;;;;;;;OAOG;IACH,qBAAqB,0BAA0B;IAC/C,qEAAqE;IACrE,wBAAwB,6BAA6B;CACxD;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,cAAc,EAAiD,CAAC"}
+{"version":3,"file":"user-permission.enum.d.ts","sourceRoot":"","sources":["../../../src/enum/user-permission.enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,oBAAY,cAAc;IAItB,WAAW,gBAAgB;IAC3B,aAAa,kBAAkB;IAC/B,sFAAsF;IACtF,aAAa,kBAAkB;IAG/B,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAG3B,eAAe,oBAAoB;IACnC,6EAA6E;IAC7E,iBAAiB,sBAAsB;IACvC;;;OAGG;IACH,sBAAsB,2BAA2B;IAGjD,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAG3B,YAAY,iBAAiB;IAC7B,aAAa,kBAAkB;IAC/B,cAAc,mBAAmB;IAKjC,qEAAqE;IACrE,qBAAqB,0BAA0B;IAC/C,uBAAuB,4BAA4B;IACnD,uBAAuB,4BAA4B;IACnD,uBAAuB,4BAA4B;IAGnD;;;;OAIG;IACH,oBAAoB,yBAAyB;IAC7C,sBAAsB,2BAA2B;IAGjD;;;;OAIG;IACH,sBAAsB,2BAA2B;IAGjD,qBAAqB,0BAA0B;IAC/C,yFAAyF;IACzF,uBAAuB,4BAA4B;IAGnD,mEAAmE;IACnE,wBAAwB,6BAA6B;IACrD;;;;;;;OAOG;IACH,0BAA0B,+BAA+B;IAGzD,kBAAkB,uBAAuB;IACzC,2DAA2D;IAC3D,oBAAoB,yBAAyB;IAG7C;;;;;OAKG;IACH,qBAAqB,0BAA0B;IAC/C;;;;;;OAMG;IACH,wBAAwB,6BAA6B;IAGrD,wFAAwF;IACxF,sBAAsB,2BAA2B;IACjD;;;;;;;;OAQG;IACH,wBAAwB,6BAA6B;IAGrD,sEAAsE;IACtE,uBAAuB,4BAA4B;IACnD;;;;;OAKG;IACH,yBAAyB,8BAA8B;IAGvD;;;;;OAKG;IACH,qBAAqB,0BAA0B;IAC/C;;;;;;;OAOG;IACH,qBAAqB,0BAA0B;IAC/C,qEAAqE;IACrE,wBAAwB,6BAA6B;IAKrD,kFAAkF;IAClF,mBAAmB,wBAAwB;IAC3C;;;;;;OAMG;IACH,qBAAqB,0BAA0B;IAG/C,2FAA2F;IAC3F,mBAAmB,wBAAwB;IAC3C,gDAAgD;IAChD,qBAAqB,0BAA0B;IAG/C;;;;;;;OAOG;IACH,wBAAwB,6BAA6B;IACrD,yFAAyF;IACzF,0BAA0B,+BAA+B;IACzD;;;;;;OAMG;IACH,0BAA0B,+BAA+B;IAGzD;;;;;;OAMG;IACH,mBAAmB,wBAAwB;IAG3C,gBAAgB,qBAAqB;IACrC,8FAA8F;IAC9F,kBAAkB,uBAAuB;IAGzC,wBAAwB,6BAA6B;IACrD,oEAAoE;IACpE,0BAA0B,+BAA+B;CAC5D;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,cAAc,EAAiD,CAAC"}

package/dist/cjs/enum/user-permission.enum.js

@@ -150,6 +150,60 @@ var UserPermission;
     UserPermission["CONDUIT_DISPATCH_SEND"] = "conduit:dispatch:send";
     /** Redrive a dead-lettered dispatch, or cancel one still pending. */
     UserPermission["CONDUIT_DISPATCH_OPERATE"] = "conduit:dispatch:operate";
+    // ══ unibox-api ═══════════════════════════════════════════════════════════
+    // ── Channel ─────────────────────────────────────────────────────────────
+    /** Read connected messaging accounts. Never exposes a channel's ingest secret. */
+    UserPermission["UNIBOX_CHANNEL_READ"] = "unibox:channel:read";
+    /**
+     * Connect, amend or disconnect a messaging account, and rotate its ingest secret.
+     *
+     * A single manage permission for the same reason as `CONDUIT_CONNECTION_MANAGE`: the
+     * dangerous act is holding the credential that lets anything post messages into a tenant's
+     * inbox, and create/update/delete carry that identically.
+     */
+    UserPermission["UNIBOX_CHANNEL_MANAGE"] = "unibox:channel:manage";
+    // ── Contact ─────────────────────────────────────────────────────────────
+    /** Read contacts. Personal data — closer to a data-export permission than a config one. */
+    UserPermission["UNIBOX_CONTACT_READ"] = "unibox:contact:read";
+    /** Create, amend or delete a contact record. */
+    UserPermission["UNIBOX_CONTACT_MANAGE"] = "unibox:contact:manage";
+    // ── Conversation ────────────────────────────────────────────────────────
+    /**
+     * Read the inbox and every message in it.
+     *
+     * **There is deliberately no separate `unibox:message:read`.** A conversation with its
+     * messages hidden is an empty row, so a permission that granted one without the other would
+     * describe a screen nobody can use — and the reverse would be a way to read a customer's
+     * messages while appearing to have no access to the inbox.
+     */
+    UserPermission["UNIBOX_CONVERSATION_READ"] = "unibox:conversation:read";
+    /** Change a conversation's status — close, snooze, reopen — and write internal notes. */
+    UserPermission["UNIBOX_CONVERSATION_MANAGE"] = "unibox:conversation:manage";
+    /**
+     * Assign a conversation to an agent or a team, and take over from the AI.
+     *
+     * Separate from `UNIBOX_CONVERSATION_MANAGE` because assignment decides whose work this is.
+     * A supervisor routing a queue and an agent closing their own conversations are different
+     * jobs, and a tenant that wants only the first to reassign should be able to say so.
+     */
+    UserPermission["UNIBOX_CONVERSATION_ASSIGN"] = "unibox:conversation:assign";
+    // ── Message ─────────────────────────────────────────────────────────────
+    /**
+     * Send a message to a contact.
+     *
+     * The sharpest permission in this service, and the reason there is no `unibox:message:*`
+     * read counterpart. Everything else here moves rows around inside our own database; this one
+     * reaches a real person on their phone, through a paid channel, and cannot be taken back.
+     */
+    UserPermission["UNIBOX_MESSAGE_SEND"] = "unibox:message:send";
+    // ── Team ────────────────────────────────────────────────────────────────
+    UserPermission["UNIBOX_TEAM_READ"] = "unibox:team:read";
+    /** Create teams and change who is in them. Routing, not permissions — identity owns those. */
+    UserPermission["UNIBOX_TEAM_MANAGE"] = "unibox:team:manage";
+    // ── Canned reply ────────────────────────────────────────────────────────
+    UserPermission["UNIBOX_CANNED_REPLY_READ"] = "unibox:canned-reply:read";
+    /** Author the saved replies every agent in the tenant will send. */
+    UserPermission["UNIBOX_CANNED_REPLY_MANAGE"] = "unibox:canned-reply:manage";
 })(UserPermission || (exports.UserPermission = UserPermission = {}));
 /**
  * Every member, for seeding the owner role and validating custom-role input.

package/dist/cjs/enum/user-permission.enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"user-permission.enum.js","sourceRoot":"","sources":["../../../src/enum/user-permission.enum.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAY,cAkJX;AAlJD,WAAY,cAAc;IACtB,4EAA4E;IAE5E,2EAA2E;IAC3E,6CAA2B,CAAA;IAC3B,iDAA+B,CAAA;IAC/B,sFAAsF;IACtF,iDAA+B,CAAA;IAE/B,2EAA2E;IAC3E,yCAAuB,CAAA;IACvB,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAE3B,2EAA2E;IAC3E,qDAAmC,CAAA;IACnC,6EAA6E;IAC7E,yDAAuC,CAAA;IACvC;;;OAGG;IACH,mEAAiD,CAAA;IAEjD,2EAA2E;IAC3E,yCAAuB,CAAA;IACvB,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAE3B,2EAA2E;IAC3E,+CAA6B,CAAA;IAC7B,iDAA+B,CAAA;IAC/B,mDAAiC,CAAA;IAEjC,4EAA4E;IAE5E,2EAA2E;IAC3E,qEAAqE;IACrE,iEAA+C,CAAA;IAC/C,qEAAmD,CAAA;IACnD,qEAAmD,CAAA;IACnD,qEAAmD,CAAA;IAEnD,2EAA2E;IAC3E;;;;OAIG;IACH,+DAA6C,CAAA;IAC7C,mEAAiD,CAAA;IAEjD,2EAA2E;IAC3E;;;;OAIG;IACH,mEAAiD,CAAA;IAEjD,2EAA2E;IAC3E,iEAA+C,CAAA;IAC/C,yFAAyF;IACzF,qEAAmD,CAAA;IAEnD,2EAA2E;IAC3E,mEAAmE;IACnE,uEAAqD,CAAA;IACrD;;;;;;;OAOG;IACH,2EAAyD,CAAA;IAEzD,2EAA2E;IAC3E,2DAAyC,CAAA;IACzC,2DAA2D;IAC3D,+DAA6C,CAAA;IAE7C,2EAA2E;IAC3E;;;;;OAKG;IACH,iEAA+C,CAAA;IAC/C;;;;;;OAMG;IACH,uEAAqD,CAAA;IAErD,2EAA2E;IAC3E,wFAAwF;IACxF,mEAAiD,CAAA;IACjD;;;;;;;;OAQG;IACH,uEAAqD,CAAA;IAErD,2EAA2E;IAC3E,sEAAsE;IACtE,qEAAmD,CAAA;IACnD;;;;;OAKG;IACH,yEAAuD,CAAA;IAEvD,2EAA2E;IAC3E;;;;;OAKG;IACH,iEAA+C,CAAA;IAC/C;;;;;;;OAOG;IACH,iEAA+C,CAAA;IAC/C,qEAAqE;IACrE,uEAAqD,CAAA;AACzD,CAAC,EAlJW,cAAc,8BAAd,cAAc,QAkJzB;AAED;;;;;GAKG;AACU,QAAA,oBAAoB,GAA8B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC"}
+{"version":3,"file":"user-permission.enum.js","sourceRoot":"","sources":["../../../src/enum/user-permission.enum.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAY,cA+MX;AA/MD,WAAY,cAAc;IACtB,4EAA4E;IAE5E,2EAA2E;IAC3E,6CAA2B,CAAA;IAC3B,iDAA+B,CAAA;IAC/B,sFAAsF;IACtF,iDAA+B,CAAA;IAE/B,2EAA2E;IAC3E,yCAAuB,CAAA;IACvB,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAE3B,2EAA2E;IAC3E,qDAAmC,CAAA;IACnC,6EAA6E;IAC7E,yDAAuC,CAAA;IACvC;;;OAGG;IACH,mEAAiD,CAAA;IAEjD,2EAA2E;IAC3E,yCAAuB,CAAA;IACvB,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAE3B,2EAA2E;IAC3E,+CAA6B,CAAA;IAC7B,iDAA+B,CAAA;IAC/B,mDAAiC,CAAA;IAEjC,4EAA4E;IAE5E,2EAA2E;IAC3E,qEAAqE;IACrE,iEAA+C,CAAA;IAC/C,qEAAmD,CAAA;IACnD,qEAAmD,CAAA;IACnD,qEAAmD,CAAA;IAEnD,2EAA2E;IAC3E;;;;OAIG;IACH,+DAA6C,CAAA;IAC7C,mEAAiD,CAAA;IAEjD,2EAA2E;IAC3E;;;;OAIG;IACH,mEAAiD,CAAA;IAEjD,2EAA2E;IAC3E,iEAA+C,CAAA;IAC/C,yFAAyF;IACzF,qEAAmD,CAAA;IAEnD,2EAA2E;IAC3E,mEAAmE;IACnE,uEAAqD,CAAA;IACrD;;;;;;;OAOG;IACH,2EAAyD,CAAA;IAEzD,2EAA2E;IAC3E,2DAAyC,CAAA;IACzC,2DAA2D;IAC3D,+DAA6C,CAAA;IAE7C,2EAA2E;IAC3E;;;;;OAKG;IACH,iEAA+C,CAAA;IAC/C;;;;;;OAMG;IACH,uEAAqD,CAAA;IAErD,2EAA2E;IAC3E,wFAAwF;IACxF,mEAAiD,CAAA;IACjD;;;;;;;;OAQG;IACH,uEAAqD,CAAA;IAErD,2EAA2E;IAC3E,sEAAsE;IACtE,qEAAmD,CAAA;IACnD;;;;;OAKG;IACH,yEAAuD,CAAA;IAEvD,2EAA2E;IAC3E;;;;;OAKG;IACH,iEAA+C,CAAA;IAC/C;;;;;;;OAOG;IACH,iEAA+C,CAAA;IAC/C,qEAAqE;IACrE,uEAAqD,CAAA;IAErD,4EAA4E;IAE5E,2EAA2E;IAC3E,kFAAkF;IAClF,6DAA2C,CAAA;IAC3C;;;;;;OAMG;IACH,iEAA+C,CAAA;IAE/C,2EAA2E;IAC3E,2FAA2F;IAC3F,6DAA2C,CAAA;IAC3C,gDAAgD;IAChD,iEAA+C,CAAA;IAE/C,2EAA2E;IAC3E;;;;;;;OAOG;IACH,uEAAqD,CAAA;IACrD,yFAAyF;IACzF,2EAAyD,CAAA;IACzD;;;;;;OAMG;IACH,2EAAyD,CAAA;IAEzD,2EAA2E;IAC3E;;;;;;OAMG;IACH,6DAA2C,CAAA;IAE3C,2EAA2E;IAC3E,uDAAqC,CAAA;IACrC,8FAA8F;IAC9F,2DAAyC,CAAA;IAEzC,2EAA2E;IAC3E,uEAAqD,CAAA;IACrD,oEAAoE;IACpE,2EAAyD,CAAA;AAC7D,CAAC,EA/MW,cAAc,8BAAd,cAAc,QA+MzB;AAED;;;;;GAKG;AACU,QAAA,oBAAoB,GAA8B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC"}

package/dist/esm/api/unibox/canned-reply.type.d.ts

@@ -0,0 +1,49 @@
+import type { IsoDateTime } from '../../type/iso-date-time.type.js';
+import type { Nullable } from '../../type/nil.type.js';
+import type { Paginated } from '../../type/paginated.type.js';
+import type { UUID } from '../../type/uuid.type.js';
+/**
+ * A saved reply an agent can insert into a message.
+ *
+ * **Inserted into the composer, never sent by itself.** A canned reply is text an agent chooses
+ * and can edit before sending — it is not an automation, and there is no endpoint that sends one
+ * directly. That line is what keeps this out of §14's no-scripting territory: the moment a saved
+ * reply can fire on a condition, we have built a rules engine in a chat product.
+ */
+export interface CannedReply {
+    id: UUID;
+    /** What an agent types to find it, e.g. `/hours`. Unique within the tenant. */
+    shortcut: string;
+    title: string;
+    /**
+     * The text, with `{{placeholders}}` substituted client-side at insert time.
+     *
+     * Substitution is the client's job on purpose. The server would have to resolve them at send
+     * time, which means an agent could send a message whose final text they never saw — and the
+     * one thing an agent must always be able to do is read what they are about to send.
+     */
+    body: string;
+    /** For grouping in the picker. Null is the ungrouped bucket. */
+    category: Nullable<string>;
+    createdByUserId: Nullable<UUID>;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+/** `GET /api/v1/canned-replies`. Offset-paged. */
+export type CannedRepliesPage = Paginated<CannedReply>;
+/** `POST /api/v1/canned-replies`. */
+export interface CreateCannedReplyBody {
+    /** Lowercase, `[a-z0-9-]`, no leading slash — the UI supplies that. */
+    shortcut: string;
+    title: string;
+    body: string;
+    category?: Nullable<string>;
+}
+/** `PATCH /api/v1/canned-replies/:id`. */
+export interface UpdateCannedReplyBody {
+    shortcut?: string;
+    title?: string;
+    body?: string;
+    category?: Nullable<string>;
+}
+//# sourceMappingURL=canned-reply.type.d.ts.map

package/dist/esm/api/unibox/canned-reply.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canned-reply.type.d.ts","sourceRoot":"","sources":["../../../../src/api/unibox/canned-reply.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,IAAI,CAAC;IAET,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;IAEjB,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb,gEAAgE;IAChE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE3B,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAEhC,SAAS,EAAE,WAAW,CAAC;IACvB,SAAS,EAAE,WAAW,CAAC;CAC1B;AAED,kDAAkD;AAClD,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC,WAAW,CAAC,CAAC;AAEvD,qCAAqC;AACrC,MAAM,WAAW,qBAAqB;IAClC,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC/B"}

package/dist/esm/api/unibox/canned-reply.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=canned-reply.type.js.map

package/dist/esm/api/unibox/canned-reply.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canned-reply.type.js","sourceRoot":"","sources":["../../../../src/api/unibox/canned-reply.type.ts"],"names":[],"mappings":""}

package/dist/esm/api/unibox/channel-platform.enum.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The messaging network a channel is connected to.
+ *
+ * This is Unibox's vocabulary, not Conduit's. Conduit knows about *connectors* — a set of hosts
+ * and operations someone wrote down — and has no idea that any of them carry conversations.
+ * Unibox knows that a WhatsApp message and an Instagram message are the same kind of thing and
+ * belong in one inbox, which is the whole product.
+ *
+ * The members are the platforms Unibox can **normalize**, which is a stricter bar than the ones
+ * Conduit can talk to: normalizing means we can read a provider's webhook into a contact, a
+ * conversation and a message, and write a reply back. Adding one is a normalizer plus a
+ * connector manifest, and is a minor version here.
+ */
+export declare enum ChannelPlatform {
+    /** WhatsApp Cloud API. The first real platform, and the one `conduit-api` ships a manifest for. */
+    WHATSAPP = "whatsapp",
+    /** Instagram Direct, via the Messenger Platform. */
+    INSTAGRAM = "instagram",
+    /** Facebook Messenger. */
+    MESSENGER = "messenger",
+    /**
+     * A loopback platform for local development and tests, matching Conduit's `local-echo`
+     * connector.
+     *
+     * It exists for the same reason that connector does: the entire pipeline — receive,
+     * normalize, thread, reply, dispatch — is provable without a Meta app, and a real Meta app
+     * would only prove we can talk to Meta. It is a first-class member rather than a test double
+     * so the normalizer registry has no branch that only exists under Jest.
+     */
+    ECHO = "echo"
+}
+//# sourceMappingURL=channel-platform.enum.d.ts.map

package/dist/esm/api/unibox/channel-platform.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-platform.enum.d.ts","sourceRoot":"","sources":["../../../../src/api/unibox/channel-platform.enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,oBAAY,eAAe;IACvB,mGAAmG;IACnG,QAAQ,aAAa;IAErB,oDAAoD;IACpD,SAAS,cAAc;IAEvB,0BAA0B;IAC1B,SAAS,cAAc;IAEvB;;;;;;;;OAQG;IACH,IAAI,SAAS;CAChB"}

package/dist/esm/api/unibox/channel-platform.enum.js

@@ -0,0 +1,33 @@
+/**
+ * The messaging network a channel is connected to.
+ *
+ * This is Unibox's vocabulary, not Conduit's. Conduit knows about *connectors* — a set of hosts
+ * and operations someone wrote down — and has no idea that any of them carry conversations.
+ * Unibox knows that a WhatsApp message and an Instagram message are the same kind of thing and
+ * belong in one inbox, which is the whole product.
+ *
+ * The members are the platforms Unibox can **normalize**, which is a stricter bar than the ones
+ * Conduit can talk to: normalizing means we can read a provider's webhook into a contact, a
+ * conversation and a message, and write a reply back. Adding one is a normalizer plus a
+ * connector manifest, and is a minor version here.
+ */
+export var ChannelPlatform;
+(function (ChannelPlatform) {
+    /** WhatsApp Cloud API. The first real platform, and the one `conduit-api` ships a manifest for. */
+    ChannelPlatform["WHATSAPP"] = "whatsapp";
+    /** Instagram Direct, via the Messenger Platform. */
+    ChannelPlatform["INSTAGRAM"] = "instagram";
+    /** Facebook Messenger. */
+    ChannelPlatform["MESSENGER"] = "messenger";
+    /**
+     * A loopback platform for local development and tests, matching Conduit's `local-echo`
+     * connector.
+     *
+     * It exists for the same reason that connector does: the entire pipeline — receive,
+     * normalize, thread, reply, dispatch — is provable without a Meta app, and a real Meta app
+     * would only prove we can talk to Meta. It is a first-class member rather than a test double
+     * so the normalizer registry has no branch that only exists under Jest.
+     */
+    ChannelPlatform["ECHO"] = "echo";
+})(ChannelPlatform || (ChannelPlatform = {}));
+//# sourceMappingURL=channel-platform.enum.js.map

package/dist/esm/api/unibox/channel-platform.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-platform.enum.js","sourceRoot":"","sources":["../../../../src/api/unibox/channel-platform.enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAN,IAAY,eAoBX;AApBD,WAAY,eAAe;IACvB,mGAAmG;IACnG,wCAAqB,CAAA;IAErB,oDAAoD;IACpD,0CAAuB,CAAA;IAEvB,0BAA0B;IAC1B,0CAAuB,CAAA;IAEvB;;;;;;;;OAQG;IACH,gCAAa,CAAA;AACjB,CAAC,EApBW,eAAe,KAAf,eAAe,QAoB1B"}

package/dist/esm/api/unibox/channel.type.d.ts

@@ -0,0 +1,110 @@
+import type { IsoDateTime } from '../../type/iso-date-time.type.js';
+import type { Nullable } from '../../type/nil.type.js';
+import type { Paginated } from '../../type/paginated.type.js';
+import type { UUID } from '../../type/uuid.type.js';
+import type { ChannelPlatform } from './channel-platform.enum.js';
+/**
+ * One messaging account a tenant has connected — a WhatsApp number, an Instagram business
+ * account, a Facebook page.
+ *
+ * A channel is the seam between Unibox and Conduit, and it points at Conduit twice, in opposite
+ * directions:
+ *
+ * - **Inbound**, Conduit forwards a provider's raw webhook to Unibox and presents this channel's
+ *   ingest secret. Conduit does not parse it — it cannot, because §11 forbids it knowing what a
+ *   chat is — so normalizing the bytes into a message is Unibox's job.
+ * - **Outbound**, a reply is submitted to Conduit naming `connectionKey` and `sendOperation`.
+ *   Unibox never calls the Graph API itself (§12).
+ *
+ * Neither reference is a foreign key, because they name rows in another service's database. A
+ * `connectionKey` that no longer resolves is a misconfiguration Unibox reports; it is not
+ * something Unibox can prevent, and pretending otherwise would mean Unibox reading Conduit's
+ * tables, which is exactly what §2 forbids.
+ */
+export interface Channel {
+    id: UUID;
+    /** Tenant-scoped, stable, and how a normalizer is chosen for inbound traffic. */
+    key: string;
+    name: string;
+    platform: ChannelPlatform;
+    /**
+     * The account's own identifier at the provider — a WhatsApp phone-number id, an Instagram
+     * account id.
+     *
+     * Stored because a provider's webhook names the *recipient* account, and a tenant may have
+     * several channels on one platform. Without it there is no way to tell which of two WhatsApp
+     * numbers a message arrived at, and both would look equally plausible.
+     */
+    externalAccountId: string;
+    /** Conduit connection a reply is dispatched through. Loose reference into another service. */
+    connectionKey: string;
+    /** Which of that connector's operations sends a message. */
+    sendOperation: string;
+    /**
+     * Whether this channel accepts inbound traffic and sends replies.
+     *
+     * Turning it off stops new conversations and refuses sends. It does **not** delete anything
+     * already received: a channel a customer disconnected still has a history someone needs to
+     * read.
+     */
+    isActive: boolean;
+    /**
+     * Whether an ingest secret is currently set.
+     *
+     * A boolean, never the value. The secret is what authenticates Conduit to Unibox, so it is
+     * envelope-encrypted, returned by no endpoint, and shown to the operator exactly once — at
+     * the moment it is generated, when it also has to be pasted into Conduit's destination
+     * headers. Same control as an endpoint's signing secret in Conduit.
+     */
+    hasIngestSecret: boolean;
+    /** When a message was last received or sent here. Null until the first one. */
+    lastActivityAt: Nullable<IsoDateTime>;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+/** `GET /api/v1/channels`. Offset-paged: a tenant has a handful of channels, not a stream of them. */
+export type ChannelsPage = Paginated<Channel>;
+/** `POST /api/v1/channels`. */
+export interface CreateChannelBody {
+    /** Lowercase, `[a-z0-9-]`. Unique within the tenant and immutable once created. */
+    key: string;
+    name: string;
+    platform: ChannelPlatform;
+    externalAccountId: string;
+    connectionKey: string;
+    /** Defaults to the platform's conventional send operation when omitted. */
+    sendOperation?: Nullable<string>;
+}
+/**
+ * `PATCH /api/v1/channels/:id`.
+ *
+ * `key` and `platform` are absent on purpose. The key is what an ingest request resolves and what
+ * an operator wrote into Conduit's configuration; the platform decides which normalizer reads the
+ * history already stored against this channel. Changing either would silently reinterpret rows
+ * that are already there, so both are create-only — delete and recreate is the honest path.
+ */
+export interface UpdateChannelBody {
+    name?: string;
+    externalAccountId?: string;
+    connectionKey?: string;
+    sendOperation?: string;
+    isActive?: boolean;
+}
+/**
+ * `POST /api/v1/channels/:id/ingest-secret` — the **only** response that ever carries the secret.
+ *
+ * Rotating replaces the stored value immediately, so the previous secret stops working the moment
+ * this returns. That is deliberate and it is a brief outage by design: an ingest secret that
+ * overlapped with its replacement would mean a leaked one keeps working for as long as the
+ * overlap, which is the thing rotation exists to end.
+ */
+export interface ChannelIngestSecretResponse {
+    channelId: UUID;
+    /** Shown once. Not stored in retrievable form, and no endpoint returns it again. */
+    ingestSecret: string;
+    /** The URL to configure as the destination in Conduit, for convenience. */
+    ingestUrl: string;
+    /** The header Conduit must carry the secret in. */
+    ingestHeaderName: string;
+}
+//# sourceMappingURL=channel.type.d.ts.map

package/dist/esm/api/unibox/channel.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.type.d.ts","sourceRoot":"","sources":["../../../../src/api/unibox/channel.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,OAAO;IACpB,EAAE,EAAE,IAAI,CAAC;IAET,iFAAiF;IACjF,GAAG,EAAE,MAAM,CAAC;IAEZ,IAAI,EAAE,MAAM,CAAC;IAEb,QAAQ,EAAE,eAAe,CAAC;IAE1B;;;;;;;OAOG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B,8FAA8F;IAC9F,aAAa,EAAE,MAAM,CAAC;IAEtB,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;;;;OAOG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB,+EAA+E;IAC/E,cAAc,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAEtC,SAAS,EAAE,WAAW,CAAC;IACvB,SAAS,EAAE,WAAW,CAAC;CAC1B;AAED,sGAAsG;AACtG,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;AAE9C,+BAA+B;AAC/B,MAAM,WAAW,iBAAiB;IAC9B,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IAEZ,IAAI,EAAE,MAAM,CAAC;IAEb,QAAQ,EAAE,eAAe,CAAC;IAE1B,iBAAiB,EAAE,MAAM,CAAC;IAE1B,aAAa,EAAE,MAAM,CAAC;IAEtB,2EAA2E;IAC3E,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,2BAA2B;IACxC,SAAS,EAAE,IAAI,CAAC;IAEhB,oFAAoF;IACpF,YAAY,EAAE,MAAM,CAAC;IAErB,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAElB,mDAAmD;IACnD,gBAAgB,EAAE,MAAM,CAAC;CAC5B"}

package/dist/esm/api/unibox/channel.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=channel.type.js.map

package/dist/esm/api/unibox/channel.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.type.js","sourceRoot":"","sources":["../../../../src/api/unibox/channel.type.ts"],"names":[],"mappings":""}

package/dist/esm/api/unibox/contact.type.d.ts

@@ -0,0 +1,102 @@
+import type { CursorPage } from '../../type/cursor-page.type.js';
+import type { IsoDateTime } from '../../type/iso-date-time.type.js';
+import type { Nullable } from '../../type/nil.type.js';
+import type { UUID } from '../../type/uuid.type.js';
+import type { ChannelPlatform } from './channel-platform.enum.js';
+/**
+ * One way of reaching a contact on one platform.
+ *
+ * A person is not a phone number. The same human messages a business from WhatsApp on Monday and
+ * from Instagram on Thursday, and an inbox that treats those as two strangers is an inbox that
+ * loses the thread — so identities are a child collection rather than columns on the contact.
+ *
+ * That shape is what makes merging possible later without a migration. Merging is **not built**;
+ * the modelling for it is, which is the part that is expensive to retrofit.
+ */
+export interface ContactIdentity {
+    id: UUID;
+    platform: ChannelPlatform;
+    /**
+     * The provider's own identifier for this person — a WhatsApp `wa_id`, an Instagram-scoped
+     * user id.
+     *
+     * Unique per `(tenant, platform)`. **Scoped ids are not portable across platforms**: the same
+     * person has an entirely different id on Instagram and on Messenger, and treating one as the
+     * other merges two strangers. That is why the platform is part of the key rather than the id
+     * being assumed globally unique.
+     */
+    externalId: string;
+    /** The name the provider supplied, when it supplied one. Not authoritative and often absent. */
+    displayName: Nullable<string>;
+    createdAt: IsoDateTime;
+}
+/**
+ * A person the tenant talks to.
+ *
+ * Personal data, deliberately minimal: Unibox stores what it needs to thread a conversation and
+ * address someone by name. A CRM's worth of fields belongs in the vertical that needs them, and
+ * §17's GDPR line is materially cheaper to honour on a small table.
+ */
+export interface Contact {
+    id: UUID;
+    /**
+     * The name shown in the inbox.
+     *
+     * Editable by an agent, because a provider's display name is frequently a handle or absent,
+     * and correcting it is the first thing anyone does. Falls back to the first identity's
+     * `displayName`, then to its `externalId`.
+     */
+    displayName: string;
+    email: Nullable<string>;
+    /** E.164 where known. Not the same as a WhatsApp identity's `externalId`, which is scoped. */
+    phone: Nullable<string>;
+    /** Free-form agent notes. Not shown to the contact and never sent anywhere. */
+    notes: Nullable<string>;
+    /** Lowercased, deduplicated. For filtering the inbox, not for automation. */
+    tags: string[];
+    identities: ContactIdentity[];
+    /** When this contact last sent or received a message. Null until the first one. */
+    lastActivityAt: Nullable<IsoDateTime>;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+/** `GET /api/v1/contacts`. Cursor-paged: inbound traffic appends to it while it is being read. */
+export type ContactsPage = CursorPage<Contact>;
+/** Query for `GET /api/v1/contacts`. */
+export interface GetContactsQuery {
+    limit?: number;
+    /** Opaque cursor from the previous page's `nextCursor`. Never parse it. */
+    after?: Nullable<string>;
+    /** Case-insensitive substring of the display name, email or phone. */
+    search?: Nullable<string>;
+    tag?: Nullable<string>;
+}
+/**
+ * `POST /api/v1/contacts`.
+ *
+ * Creating a contact by hand is the uncommon path — almost every contact arrives because someone
+ * messaged in, and inbound creates them. This exists so an agent can prepare a record before a
+ * conversation starts, and so a vertical can seed one.
+ */
+export interface CreateContactBody {
+    displayName: string;
+    email?: Nullable<string>;
+    phone?: Nullable<string>;
+    notes?: Nullable<string>;
+    tags?: Nullable<string[]>;
+}
+/**
+ * `PATCH /api/v1/contacts/:id`.
+ *
+ * `identities` is absent: an identity is asserted by a provider, not chosen by an agent. Adding
+ * one by hand is how two strangers get merged into one record, and there is no undo for that.
+ */
+export interface UpdateContactBody {
+    displayName?: string;
+    email?: Nullable<string>;
+    phone?: Nullable<string>;
+    notes?: Nullable<string>;
+    /** Replaces the whole set. Omit to leave it alone; `[]` clears it. */
+    tags?: Nullable<string[]>;
+}
+//# sourceMappingURL=contact.type.d.ts.map

package/dist/esm/api/unibox/contact.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact.type.d.ts","sourceRoot":"","sources":["../../../../src/api/unibox/contact.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,IAAI,CAAC;IAET,QAAQ,EAAE,eAAe,CAAC;IAE1B;;;;;;;;OAQG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB,gGAAgG;IAChG,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE9B,SAAS,EAAE,WAAW,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACpB,EAAE,EAAE,IAAI,CAAC;IAET;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAExB,8FAA8F;IAC9F,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAExB,+EAA+E;IAC/E,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAExB,6EAA6E;IAC7E,IAAI,EAAE,MAAM,EAAE,CAAC;IAEf,UAAU,EAAE,eAAe,EAAE,CAAC;IAE9B,mFAAmF;IACnF,cAAc,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAEtC,SAAS,EAAE,WAAW,CAAC;IACvB,SAAS,EAAE,WAAW,CAAC;CAC1B;AAED,kGAAkG;AAClG,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;AAE/C,wCAAwC;AACxC,MAAM,WAAW,gBAAgB;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,2EAA2E;IAC3E,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAEzB,sEAAsE;IACtE,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE1B,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;CAC7B;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAEzB,sEAAsE;IACtE,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;CAC7B"}

package/dist/esm/api/unibox/contact.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contact.type.js.map

package/dist/esm/api/unibox/contact.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact.type.js","sourceRoot":"","sources":["../../../../src/api/unibox/contact.type.ts"],"names":[],"mappings":""}

package/dist/esm/api/unibox/conversation-status.enum.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Where one conversation is in an agent's working day.
+ *
+ * These are **workflow** states, not delivery states — nothing here says whether a message
+ * reached anyone. `MessageStatus` answers that, and conflating the two is how an inbox ends up
+ * showing a conversation as "failed".
+ *
+ * There is deliberately no `ARCHIVED`. Closing is already the "I am done with this" state, and a
+ * second one just moves the question of which list a conversation belongs in from the filter to
+ * the operator.
+ */
+export declare enum ConversationStatus {
+    /** Needs a human. The default for anything with an unanswered inbound message. */
+    OPEN = "open",
+    /**
+     * Answered, waiting on the contact.
+     *
+     * Distinct from `OPEN` because an inbox sorted only by "has unread" hides the conversations
+     * an agent is actually running. A new inbound message moves this back to `OPEN`.
+     */
+    PENDING = "pending",
+    /**
+     * Deliberately out of sight until `snoozedUntil`.
+     *
+     * The only status carrying a time. It exists because "I will deal with this on Monday" is
+     * otherwise expressed by closing something that is not finished, and a closed conversation is
+     * one nobody looks at again.
+     */
+    SNOOZED = "snoozed",
+    /**
+     * Finished. Reopened automatically by a new inbound message.
+     *
+     * That automatic reopen is the important half: a contact replying to a closed conversation is
+     * continuing it, and starting a second thread would split one person's history across two
+     * rows for no reason a customer would recognise.
+     */
+    CLOSED = "closed"
+}
+//# sourceMappingURL=conversation-status.enum.d.ts.map

package/dist/esm/api/unibox/conversation-status.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-status.enum.d.ts","sourceRoot":"","sources":["../../../../src/api/unibox/conversation-status.enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,oBAAY,kBAAkB;IAC1B,kFAAkF;IAClF,IAAI,SAAS;IAEb;;;;;OAKG;IACH,OAAO,YAAY;IAEnB;;;;;;OAMG;IACH,OAAO,YAAY;IAEnB;;;;;;OAMG;IACH,MAAM,WAAW;CACpB"}