ab-ecosystem-cpass 1.0.7 → 1.0.8

package/dist/types/canned-reply.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Canned replies: message payloads an agent sends into a chat without retyping
+ * them.
+ *
+ * Two kinds, and the difference is who gets the last word. A `CANNED` reply
+ * sends every message it holds, exactly as stored, in order, the moment it is
+ * picked -- so a three-message reply puts three messages on the contact's phone
+ * from one keystroke. A `QUICK` reply drops its text into the agent's composer
+ * to edit before sending, which is why it holds exactly one text message and
+ * nothing else: there is one composer, and nowhere to put an image in it.
+ *
+ * Declared here rather than imported from `@crm/contracts` so the published
+ * package has no private dependencies; kept in step with the zod schemas.
+ */
+import type { JsonObject, ListQuery } from './common';
+import type { MessageContent } from './inbox';
+export type CannedReplyType = 'CANNED' | 'QUICK';
+/**
+ * The channel shape the stored payload is written for -- a channel *type*, never
+ * a channel id, so one reply works across every number on the account.
+ *
+ * `whatsapp` is the only value the panel offers today, and the reason is
+ * `whatsapp_api` below: a stored message is a literal WhatsApp Cloud API message
+ * object, so a reply is only sendable on a channel that speaks that shape.
+ */
+export type CannedReplyChannel = 'whatsapp' | 'sms' | 'email' | 'rcs' | 'webchat';
+/** Most messages one reply may hold. A `CANNED` reply sends all of them. */
+export declare const MAX_CANNED_REPLY_MESSAGES = 10;
+/**
+ * The editor's own working copy of a message.
+ *
+ * Stored and returned verbatim, and never read by the server: it is the form
+ * state a composer needs to reopen the message for editing -- which media type
+ * was chosen, whether the upload was still local, the button rows before they
+ * were flattened into an action. `whatsapp_api` is the authority on what gets
+ * sent; this is the authority on what the edit screen shows.
+ *
+ * Optional. A reply created through the API without one is valid; an editor just
+ * opens it in whatever state it can infer from `whatsapp_api`.
+ */
+export type CannedReplyDraft = JsonObject;
+/**
+ * One message in a reply, as written by the current editor.
+ *
+ * `whatsapp_api` is the payload as the provider takes it -- the same object
+ * `inbox.messages.send()` accepts as `content`. Only `type` is promised; by
+ * convention the body sits under a key of the same name.
+ *
+ * Variable placeholders in a body are stored **literally**. Substitution happens
+ * at the moment of sending, against the contact in front of the agent; there is
+ * no contact when a reply is written.
+ */
+export interface CannedReplyMessageV2 {
+    version: '2';
+    whatsapp_api: MessageContent;
+    internal?: CannedReplyDraft;
+}
+/**
+ * A message row written before the editor was rewritten.
+ *
+ * These carry a flat `type` plus a `components` array in template form, and are
+ * returned exactly as stored -- synthesising a `whatsapp_api` for them would
+ * mean inventing a payload nobody approved. Narrow with
+ * `message.version === '2'` before reading `whatsapp_api`; everything else is one
+ * of these. New writes are v2 only: there is no way to create one of these
+ * through the API.
+ */
+export type CannedReplyMessageLegacy = JsonObject & {
+    version?: undefined;
+};
+export type CannedReplyMessage = CannedReplyMessageV2 | CannedReplyMessageLegacy;
+/** A message on the way *in* -- always v2, because that is all a write accepts. */
+export interface CannedReplyMessageInput {
+    /** Defaults to `'2'`. The only accepted value. */
+    version?: '2';
+    whatsapp_api: MessageContent;
+    internal?: CannedReplyDraft;
+}
+export interface CreateCannedReplyInput {
+    /**
+     * What the agent types after `/`. Trimmed, 1..120 characters, unique per
+     * account -- a duplicate is a 409, not a silent overwrite.
+     */
+    name: string;
+    type: CannedReplyType;
+    /** Default `'whatsapp'`. */
+    channel?: CannedReplyChannel;
+    /** 1..{@link MAX_CANNED_REPLY_MESSAGES}. A `QUICK` reply must hold exactly one, of type `text`. */
+    messages: CannedReplyMessageInput[];
+}
+/**
+ * Any subset of the create body.
+ *
+ * `messages` is replaced whole, never merged: a reply is an ordered sequence, and
+ * there is no sensible way to patch element two of a list whose length is also
+ * changing. Send the array you want stored.
+ */
+export type UpdateCannedReplyInput = Partial<CreateCannedReplyInput>;
+/**
+ * `search` matches the name, case-insensitively, anywhere in it; the term is
+ * escaped, so `(` and `.` are searched for rather than compiled. `type` and
+ * `channel` narrow the list -- the chat panel passes both, wanting the replies
+ * usable on the channel of the chat that is open.
+ */
+export interface ListCannedRepliesQuery extends ListQuery {
+    type?: CannedReplyType;
+    channel?: CannedReplyChannel;
+}
+/**
+ * A stored reply.
+ *
+ * `messages` comes back in full from every endpoint, list included. It is the
+ * entire point of the record, and a picker that had to fetch each reply before it
+ * could show what the reply says would make one request per keystroke.
+ */
+export interface CannedReply {
+    id: string;
+    name: string;
+    type: CannedReplyType;
+    channel: CannedReplyChannel;
+    messages: CannedReplyMessage[];
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types/canned-reply.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CANNED_REPLY_MESSAGES = void 0;
+/** Most messages one reply may hold. A `CANNED` reply sends all of them. */
+exports.MAX_CANNED_REPLY_MESSAGES = 10;
+//# sourceMappingURL=canned-reply.js.map

package/dist/types/canned-reply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canned-reply.js","sourceRoot":"","sources":["../../src/types/canned-reply.ts"],"names":[],"mappings":";;;AA6BA,4EAA4E;AAC/D,QAAA,yBAAyB,GAAG,EAAE,CAAC"}

package/dist/types/datastore.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Data Store: a customer's own MongoDB, registered with the platform.
+ *
+ * Three nested things:
+ *
+ * 1. **A data store** -- a connection to a database *you* own. The platform
+ *    holds the credential and nothing else: no copy of the data, no mirror.
+ * 2. **A collection** -- a schema you declare, naming a collection inside that
+ *    database and the fields in it.
+ * 3. **Records** -- the documents. They live in your database, and every record
+ *    call is a live round trip to your cluster.
+ *
+ * The thing to keep in mind throughout: the platform is not the system of
+ * record. Anything else holding those credentials can change the same data, so
+ * a read is always current and a schema is a *declaration* rather than a
+ * guarantee -- a document may carry fields the schema never mentioned, or lack
+ * ones it does.
+ */
+/** The five storage types a field can declare. */
+export type DataStoreFieldType = 'String' | 'Number' | 'Boolean' | 'Date' | 'Array';
+/**
+ * One declared field.
+ *
+ * `name` is **slugged** by the server: punctuation is dropped, spaces and
+ * hyphens become underscores, and the result is lowercased, so `"First Name"`
+ * comes back as `first_name`. Use the name the response gives you as the key in
+ * every record payload -- it is the key the document actually has.
+ */
+export interface DataStoreField {
+    name: string;
+    type: DataStoreFieldType;
+    /** For display. Never used as a key, so it can be whatever reads well. */
+    label?: string;
+    /**
+     * Applied when a record omits the field. `String`, `Number` and `Boolean`
+     * only: a `Date` default would have to mean "now", and an `Array` default
+     * shared between documents is a trap.
+     */
+    default?: string | number | boolean;
+}
+/** The two ways to name a database. */
+export type DataStoreCredentials = {
+    type: 'field';
+    /** Hostname only: `cluster0.ab12c.mongodb.net`. No scheme, no port, no path. */
+    host: string;
+    username: string;
+    password: string;
+    database: string;
+} | {
+    type: 'string';
+    /**
+     * A full connection string. Must name a database --
+     * `mongodb+srv://user:pass@host/<database>` -- because a URI without one
+     * silently puts every record in a database called `test`.
+     */
+    uri: string;
+};
+export interface CreateDataStoreInput {
+    title: string;
+    credentials: DataStoreCredentials;
+}
+/**
+ * Rename, re-point, or both.
+ *
+ * Credentials are replaced whole or not at all: a host without its matching
+ * password is not a partial credential, it is a broken one. New credentials are
+ * tested before anything is stored.
+ */
+export interface UpdateDataStoreInput {
+    title?: string;
+    credentials?: DataStoreCredentials;
+}
+/**
+ * A registered data store.
+ *
+ * **No credential is ever returned.** The password is encrypted at rest and does
+ * not come back in any form; `summary` is the connection with its password
+ * replaced by `***`, which is what an edit screen needs to show which database
+ * it is looking at.
+ */
+export interface DataStore {
+    id: string;
+    title: string;
+    credentialType: 'field' | 'string';
+    engine: 'mongodb';
+    host: string;
+    database: string;
+    username: string;
+    /** The connection string with the password removed, for display. */
+    summary: string;
+    /** When the connection was last proven to work: a create, an update, or a test. */
+    verifiedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** What `test()` found. */
+export interface DataStoreTestResult {
+    ok: boolean;
+    /** The database the credential actually lands in. */
+    database: string;
+    /**
+     * Collections already in that database, up to 100, `system.*` excluded.
+     *
+     * Empty when the database user has no `listCollections` privilege, which a
+     * least-privilege credential legitimately may not -- it does not mean the
+     * database is empty.
+     */
+    collections: string[];
+    /** Round-trip milliseconds for the ping. A rough health signal, not a metric. */
+    latencyMs: number;
+}
+export interface CreateDataStoreCollectionInput {
+    title: string;
+    fields: DataStoreField[];
+    /**
+     * An existing collection to use instead of a new one.
+     *
+     * Omitted, the server generates `<schema id>_<slugged title>`, which cannot
+     * collide with anything already in the database. Supplied, this points at a
+     * collection you already have -- which is how a database with data in it gets
+     * used rather than duplicated.
+     *
+     * Immutable once set. A schema points at one collection for its whole life.
+     */
+    collection?: string;
+    /** Whether the chat panel offers this collection beside a conversation. */
+    show_in_chat?: boolean;
+    /** Presentation only. Nothing here changes what is stored or queryable. */
+    display?: {
+        theme?: string;
+        fields?: string[];
+    };
+}
+/**
+ * Edits to a declaration. `collection` is deliberately not editable.
+ *
+ * Changing `fields` changes validation and coercion from the next call onward
+ * and rewrites nothing already stored. Dropping a field hides the values under
+ * that key rather than deleting them; re-declaring it shows them again.
+ */
+export interface UpdateDataStoreCollectionInput {
+    title?: string;
+    fields?: DataStoreField[];
+    show_in_chat?: boolean;
+    display?: {
+        theme?: string;
+        fields?: string[];
+    };
+}
+export interface DataStoreCollection {
+    id: string;
+    storeId: string;
+    title: string;
+    /** The collection this reads and writes inside your database. */
+    collection: string;
+    fields: DataStoreField[];
+    showInChat: boolean;
+    display: {
+        theme?: string;
+        fields: string[];
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * One document, as it reads back.
+ *
+ * **Every stored key is returned**, declared or not: a collection you already
+ * had, or one another application also writes to, holds fields this schema has
+ * never heard of, and hiding your own data because the declaration is incomplete
+ * would be worse than surprising. The schema governs what can be *written*
+ * through the API; it does not filter what comes back.
+ *
+ * `_id` reads back as `id`, and dates as ISO strings.
+ */
+export type DataStoreRecord = Record<string, unknown> & {
+    id: string;
+};
+/**
+ * A record body on the way in.
+ *
+ * Keys must be declared field names. An undeclared key is a **422 naming it**,
+ * not a silent drop -- which is the one behaviour here that differs from the
+ * legacy endpoint, where a typo meant data quietly went nowhere.
+ *
+ * `null` clears a field. `id`, `_id`, `created_on` and `updated_on` are the
+ * server's: the timestamps are ignored if sent, the ids are refused.
+ */
+export type DataStoreRecordBody = Record<string, unknown>;
+/** Insert one record, or up to 1000. */
+export type InsertDataStoreRecordsInput = {
+    record: DataStoreRecordBody;
+    records?: never;
+} | {
+    records: DataStoreRecordBody[];
+    record?: never;
+};
+/**
+ * A Mongo query, as you would write it for the driver.
+ *
+ * The full language -- `$in`, `$gt`, `$or`, `$regex`, `$elemMatch` -- because it
+ * is your database and there is nothing in it you do not already own. Three
+ * operators are refused wherever they appear: `$where`, `$function` and
+ * `$accumulator`, all of which run JavaScript on your cluster.
+ *
+ * Operand values are coerced against the declared field type before the query is
+ * sent, so `{ created_on: { $gte: '2026-01-01' } }` against a `Date` field
+ * matches real dates rather than comparing a string to a date and finding
+ * nothing. `id` works as an alias for `_id` and takes the string form.
+ */
+export type DataStoreFilter = Record<string, unknown>;
+/**
+ * Paging and ordering for a record list.
+ *
+ * A type alias rather than an interface deliberately: only aliases of object
+ * literals get TypeScript's implicit index signature, which is what lets this
+ * be passed as the query record the HTTP client takes. An interface here fails
+ * to compile at the call site with a message about a missing index signature.
+ */
+export type ListDataStoreRecordsQuery = {
+    page?: number;
+    /** 1-100, default 25. */
+    rows?: number;
+    /** A field name. Defaults to `created_on`. */
+    sort?: string;
+    /** Defaults to `desc`. */
+    order?: 'asc' | 'desc';
+};
+export type SearchDataStoreRecordsInput = ListDataStoreRecordsQuery & {
+    filter: DataStoreFilter;
+};
+export interface UpdateDataStoreRecordInput {
+    record: DataStoreRecordBody;
+}
+/** The filter cannot be empty: `{}` would rewrite the whole collection. */
+export interface BulkUpdateDataStoreRecordsInput {
+    filter: DataStoreFilter;
+    update: DataStoreRecordBody;
+}
+/** The filter cannot be empty, for the same reason. */
+export interface BulkDeleteDataStoreRecordsInput {
+    filter: DataStoreFilter;
+}
+export interface DataStoreWriteResult {
+    /**
+     * Documents inserted. Can be fewer than were sent: a batch is unordered, so
+     * one document rejected by an index of yours does not abandon the rest.
+     */
+    inserted: number;
+    /** Ids of the inserted documents, in the order they were sent. */
+    ids: string[];
+}
+export interface DataStoreUpdateResult {
+    matched: number;
+    /** Lower than `matched` when a record already held the values being written. */
+    modified: number;
+}
+export interface DataStoreDeleteResult {
+    deleted: number;
+}

package/dist/types/datastore.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Data Store: a customer's own MongoDB, registered with the platform.
+ *
+ * Three nested things:
+ *
+ * 1. **A data store** -- a connection to a database *you* own. The platform
+ *    holds the credential and nothing else: no copy of the data, no mirror.
+ * 2. **A collection** -- a schema you declare, naming a collection inside that
+ *    database and the fields in it.
+ * 3. **Records** -- the documents. They live in your database, and every record
+ *    call is a live round trip to your cluster.
+ *
+ * The thing to keep in mind throughout: the platform is not the system of
+ * record. Anything else holding those credentials can change the same data, so
+ * a read is always current and a schema is a *declaration* rather than a
+ * guarantee -- a document may carry fields the schema never mentioned, or lack
+ * ones it does.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=datastore.js.map

package/dist/types/datastore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore.js","sourceRoot":"","sources":["../../src/types/datastore.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG"}

package/dist/types/index.d.ts

@@ -1,7 +1,9 @@
 export * from './common';
 export * from './contact-filter';
 export * from './audience';
+export * from './datastore';
 export * from './channels';
 export * from './inbox';
+export * from './canned-reply';
 export * from './scheduled-message';
 export * from './campaign';

package/dist/types/index.js

@@ -17,8 +17,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./common"), exports);
 __exportStar(require("./contact-filter"), exports);
 __exportStar(require("./audience"), exports);
+__exportStar(require("./datastore"), exports);
 __exportStar(require("./channels"), exports);
 __exportStar(require("./inbox"), exports);
+// After './inbox': a canned reply's stored payload is a `MessageContent`.
+__exportStar(require("./canned-reply"), exports);
 // After './inbox': a scheduled message's body is a `MessageContent`.
 __exportStar(require("./scheduled-message"), exports);
 // After './contact-filter': a campaign's audience may be a list of its entries.

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,mDAAiC;AACjC,6CAA2B;AAC3B,6CAA2B;AAC3B,0CAAwB;AACxB,qEAAqE;AACrE,sDAAoC;AACpC,gFAAgF;AAChF,6CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,mDAAiC;AACjC,6CAA2B;AAC3B,8CAA4B;AAC5B,6CAA2B;AAC3B,0CAAwB;AACxB,0EAA0E;AAC1E,iDAA+B;AAC/B,qEAAqE;AACrE,sDAAoC;AACpC,gFAAgF;AAChF,6CAA2B"}