ab-ecosystem-cpass 1.0.7 → 1.0.8

package/dist/resources/campaign-messages.js

@@ -1,18 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CampaignMessages = void 0;
-const BASE = '/v1/campaign-messages';
+const paths_1 = require("./paths");
+/** `/v1/campaigns/:id/report` -- the report is the campaign's own sub-resource. */
+const report = (campaign) => `/v1/campaigns/${(0, paths_1.seg)(campaign)}/report`;
 /**
  * Campaign reporting: what actually happened to each message.
  *
  * ```ts
- * const stats = await crm.campaignMessages.stats({ campaign });
+ * const stats = await crm.campaignMessages.stats(campaign);
  * // { total: 12480, sent: 12410, delivered: 11980, read: 7420, replied: 310, failed: 70 }
  *
- * const { data } = await crm.campaignMessages.list({ campaign, status: 'failed' });
+ * const { data } = await crm.campaignMessages.list(campaign, { status: 'failed' });
  * data[0].error; // why that one did not go
  * ```
  *
+ * Every method takes the campaign id first. A report has no meaning without one,
+ * so it is addressed as the campaign's own sub-resource --
+ * `/v1/campaigns/:id/report` -- rather than as a collection of rows that a
+ * campaign filters. The options object holds only what *narrows* a report that
+ * already exists: a message index, a status, a page.
+ *
  * ## Where these numbers come from
  *
  * One row per attempted send, written by the campaign manager as it hands each
@@ -47,18 +55,17 @@ class CampaignMessages {
     /**
      * The campaign's funnel counts.
      *
-     * `GET /v1/campaign-messages/stats?campaign=<id>` · `campaigns:read` · **200**
+     * `GET /v1/campaigns/:id/report` · `campaigns:read` · **200**
      *
      * ### Query
      *
-     * | Field | Type | Required | Notes |
-     * | --- | --- | --- | --- |
-     * | `campaign` | string | yes | The campaign id. |
-     * | `message` | number | no | One message of a multi-message campaign, zero-based. |
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `message` | number | One message of a multi-message campaign, zero-based. Omit for the whole campaign. |
      *
      * ```ts
-     * const overall = await crm.campaignMessages.stats({ campaign });
-     * const second = await crm.campaignMessages.stats({ campaign, message: 1 });
+     * const overall = await crm.campaignMessages.stats(campaign);
+     * const second = await crm.campaignMessages.stats(campaign, { message: 1 });
      * ```
      *
      * No date window: a campaign is one send, so its whole life is the only
@@ -68,19 +75,18 @@ class CampaignMessages {
      * `404 not_found` if the campaign is not the caller's -- the same answer as a
      * campaign that does not exist, so the error cannot be used to probe ids.
      */
-    stats(query) {
-        return this.http.request('GET', `${BASE}/stats`, { query });
+    stats(campaign, query = {}) {
+        return this.http.request('GET', report(campaign), { query });
     }
     /**
      * The rows behind the funnel. This is the report table.
      *
-     * `GET /v1/campaign-messages?campaign=<id>` · `campaigns:read` · **200**
+     * `GET /v1/campaigns/:id/report/messages` · `campaigns:read` · **200**
      *
      * ### Query
      *
      * | Field | Type | Default | Notes |
      * | --- | --- | --- | --- |
-     * | `campaign` | string | — | Required. |
      * | `message` | number | — | Zero-based index of one campaign message. |
      * | `status` | `sent \| delivered \| read \| replied \| failed` | — | Cumulative; see below. Omit for every row. |
      * | `exact` | boolean | `false` | Only rows sitting at `status` right now. |
@@ -96,22 +102,22 @@ class CampaignMessages {
      *
      * ```ts
      * // the two queries a report screen actually makes
-     * const failures = await crm.campaignMessages.list({ campaign, status: 'failed', rows: 100 });
-     * const unread = await crm.campaignMessages.list({ campaign, status: 'delivered', exact: true });
+     * const failures = await crm.campaignMessages.list(campaign, { status: 'failed', rows: 100 });
+     * const unread = await crm.campaignMessages.list(campaign, { status: 'delivered', exact: true });
      * ```
      *
      * `reply_type` and `replied_within_hours` are **refused** with
-     * `400 validation_failed` unless `status` is `replied`, rather than quietly
+     * `422 validation_failed` unless `status` is `replied`, rather than quietly
      * matching nothing.
      */
-    list(query) {
-        return this.http.request('GET', BASE, { query });
+    list(campaign, query = {}) {
+        return this.http.request('GET', `${report(campaign)}/messages`, { query });
     }
     /**
      * Every matching row, paged through for you. What an export is.
      *
      * ```ts
-     * for await (const row of crm.campaignMessages.iterate({ campaign })) {
+     * for await (const row of crm.campaignMessages.iterate(campaign)) {
      *   csv.write([row.identifier, row.name, row.status, row.error ?? '']);
      * }
      * ```
@@ -126,11 +132,11 @@ class CampaignMessages {
      * moving data can repeat or skip a row -- for a stable snapshot, export after
      * the campaign completes.
      */
-    async *iterate(query) {
+    async *iterate(campaign, query = {}) {
         const rows = query.rows ?? 100;
         let page = query.page ?? 1;
         for (;;) {
-            const result = await this.list({ ...query, page, rows });
+            const result = await this.list(campaign, { ...query, page, rows });
             for (const record of result.data)
                 yield record;
             if (result.data.length === 0 || page >= result.pagination.pages)
@@ -141,18 +147,17 @@ class CampaignMessages {
     /**
      * What people replied, grouped by the reply itself.
      *
-     * `GET /v1/campaign-messages/replies?campaign=<id>` · `campaigns:read` · **200**
+     * `GET /v1/campaigns/:id/report/replies` · `campaigns:read` · **200**
      *
      * ### Query
      *
      * | Field | Type | Default | Notes |
      * | --- | --- | --- | --- |
-     * | `campaign` | string | — | Required. |
      * | `message` | number | — | Zero-based index of one campaign message. |
      * | `limit` | number | `50` | Distinct replies to return, 1–200. |
      *
      * ```ts
-     * const { groups, replied, distinct } = await crm.campaignMessages.replies({ campaign });
+     * const { groups, replied, distinct } = await crm.campaignMessages.replies(campaign);
      * groups; // [{ reply: 'Yes', replyType: 'button', count: 182 }, …]
      * ```
      *
@@ -164,8 +169,10 @@ class CampaignMessages {
      * complete. A campaign that asked an open question has as many groups as it
      * has repliers, so a truncated answer there is normal rather than a problem.
      */
-    replies(query) {
-        return this.http.request('GET', `${BASE}/replies`, { query });
+    replies(campaign, query = {}) {
+        return this.http.request('GET', `${report(campaign)}/replies`, {
+            query,
+        });
     }
 }
 exports.CampaignMessages = CampaignMessages;

package/dist/resources/campaign-messages.js.map

@@ -1 +1 @@
-{"version":3,"file":"campaign-messages.js","sourceRoot":"","sources":["../../src/resources/campaign-messages.ts"],"names":[],"mappings":";;;AAWA,MAAM,IAAI,GAAG,uBAAuB,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAa,gBAAgB;IACE;IAA7B,YAA6B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,KAAgC;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAuB,KAAK,EAAE,GAAG,IAAI,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IACpF,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,IAAI,CAAC,KAAgC;QACnC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAmC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,CAAC,OAAO,CAAC,KAAgC;QAC7C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC;QAC/B,IAAI,IAAI,GAAG,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC;QAE3B,SAAS,CAAC;YACR,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YACzD,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI;gBAAE,MAAM,MAAM,CAAC;YAE/C,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK;gBAAE,OAAO;YACxE,IAAI,IAAI,CAAC,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,KAA2B;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAyB,KAAK,EAAE,GAAG,IAAI,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IACxF,CAAC;CACF;AAjID,4CAiIC"}
+{"version":3,"file":"campaign-messages.js","sourceRoot":"","sources":["../../src/resources/campaign-messages.ts"],"names":[],"mappings":";;;AAUA,mCAA8B;AAE9B,mFAAmF;AACnF,MAAM,MAAM,GAAG,CAAC,QAAgB,EAAU,EAAE,CAAC,iBAAiB,IAAA,WAAG,EAAC,QAAQ,CAAC,SAAS,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAa,gBAAgB;IACE;IAA7B,YAA6B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,KAAK,CAAC,QAAgB,EAAE,QAAmC,EAAE;QAC3D,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAuB,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,IAAI,CACF,QAAgB,EAChB,QAAmC,EAAE;QAErC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CACtB,KAAK,EACL,GAAG,MAAM,CAAC,QAAQ,CAAC,WAAW,EAC9B,EAAE,KAAK,EAAE,CACV,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,CAAC,OAAO,CACZ,QAAgB,EAChB,QAAmC,EAAE;QAErC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC;QAC/B,IAAI,IAAI,GAAG,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC;QAE3B,SAAS,CAAC;YACR,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YACnE,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI;gBAAE,MAAM,MAAM,CAAC;YAE/C,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK;gBAAE,OAAO;YACxE,IAAI,IAAI,CAAC,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,OAAO,CAAC,QAAgB,EAAE,QAA8B,EAAE;QACxD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAyB,KAAK,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE;YACrF,KAAK;SACN,CAAC,CAAC;IACL,CAAC;CACF;AA1ID,4CA0IC"}

package/dist/resources/data-stores.d.ts

@@ -0,0 +1,469 @@
+import type { BulkDeleteDataStoreRecordsInput, BulkUpdateDataStoreRecordsInput, CreateDataStoreCollectionInput, CreateDataStoreInput, DataStore, DataStoreCollection, DataStoreDeleteResult, DataStoreRecord, DataStoreTestResult, DataStoreUpdateResult, DataStoreWriteResult, InsertDataStoreRecordsInput, ListDataStoreRecordsQuery, ListQuery, Paginated, SearchDataStoreRecordsInput, UpdateDataStoreCollectionInput, UpdateDataStoreInput, UpdateDataStoreRecordInput } from '../types';
+import type { HttpClient } from '../http';
+/**
+ * Data stores: a MongoDB **you** own, registered with the platform.
+ *
+ * ```ts
+ * const store = await crm.dataStores.create({
+ *   title: 'Orders DB',
+ *   credentials: {
+ *     type: 'field',
+ *     host: 'cluster0.ab12c.mongodb.net',
+ *     username: 'crm_writer',
+ *     password: process.env.ORDERS_DB_PASSWORD!,
+ *     database: 'shop',
+ *   },
+ * });
+ *
+ * const orders = await crm.dataStoreCollections.create(store.id, {
+ *   title: 'Orders',
+ *   fields: [
+ *     { name: 'order_no', type: 'String' },
+ *     { name: 'total', type: 'Number' },
+ *     { name: 'paid', type: 'Boolean', default: false },
+ *   ],
+ * });
+ *
+ * await crm.dataStoreRecords.insert(store.id, orders.id, {
+ *   record: { order_no: 'A-1001', total: 49.9 },
+ * });
+ * ```
+ *
+ * ## What the platform holds, and what it does not
+ *
+ * It holds the credential -- encrypted -- and the schemas you declare. It holds
+ * **none of your data**: records are read from and written to your cluster on
+ * every call, so nothing here is a copy that can go stale, and nothing here
+ * survives you revoking the credential.
+ *
+ * Which also means every record call costs a round trip to your database. The
+ * platform keeps the connection open between calls, so that is one query's
+ * latency rather than a fresh TLS handshake each time, but a loop of a thousand
+ * single inserts is a thousand round trips: send them as one `insert` with
+ * `records` instead.
+ *
+ * ## Deleting never deletes your data
+ *
+ * `remove()` on a store forgets the credential and the schemas. `remove()` on a
+ * collection forgets the declaration. **Neither touches your database** -- the
+ * collections and every document in them are exactly as they were, and
+ * re-registering the same credential with the same collection name reads it all
+ * straight back. Deleting *records* is the only thing here that deletes
+ * anything of yours.
+ *
+ * ## The host must be reachable from the internet
+ *
+ * A credential pointing at a private or loopback address is refused with
+ * `422 invalid_datastore_host`: the platform would be connecting to its own
+ * network rather than to yours. Atlas users will usually also need to allow the
+ * platform's egress addresses in their project's IP access list -- the symptom
+ * otherwise is `502 datastore_unreachable` with a server-selection timeout.
+ */
+export declare class DataStores {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * `POST /v1/datastores` -- 201 with the store.
+     *
+     * ### Payload
+     *
+     * | Field | Type | Required | Notes |
+     * | --- | --- | --- | --- |
+     * | `title` | string | yes | What you call it. 1-120 characters. |
+     * | `credentials` | object | yes | Either form below. |
+     *
+     * **`credentials.type: 'field'`**
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `host` | string | Hostname only: `cluster0.ab12c.mongodb.net`. |
+     * | `username` | string | |
+     * | `password` | string | Encrypted at rest; never returned. |
+     * | `database` | string | |
+     *
+     * Assembled into `mongodb+srv://…?retryWrites=true&w=majority`, with both
+     * halves of the credential percent-encoded -- so a password containing `@`,
+     * `/` or `?` works, which it did not in the legacy panel.
+     *
+     * **`credentials.type: 'string'`**
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `uri` | string | `mongodb://` or `mongodb+srv://`, and it must name a database. |
+     *
+     * ### What happens before the row is written
+     *
+     * The credential is checked for shape, the host is resolved and refused if it
+     * is private, and a connection is opened and pinged. Only then is anything
+     * stored -- so a 201 means the database really did accept these credentials,
+     * and a store you can see is a store that worked at least once.
+     *
+     * | Status | Code | Meaning |
+     * | --- | --- | --- |
+     * | 422 | `validation_failed` | Malformed URI, a host with a scheme in it, or no database named. |
+     * | 422 | `invalid_datastore_host` | The host does not resolve, or resolves somewhere private. |
+     * | 502 | `datastore_auth_failed` | The database refused the username or password. |
+     * | 502 | `datastore_unreachable` | No answer in time -- usually an IP access list. |
+     *
+     * Scope: `datastores:write`.
+     */
+    create(input: CreateDataStoreInput): Promise<DataStore>;
+    /**
+     * `GET /v1/datastores` -- offset paginated, newest first.
+     *
+     * | Query | Type | Default | Notes |
+     * | --- | --- | --- | --- |
+     * | `page` | number | `1` | 1-based. |
+     * | `rows` | number | `25` | 1-100. |
+     * | `search` | string | — | Case-insensitive match on the title. |
+     *
+     * Scope: `datastores:read`.
+     */
+    list(query?: Partial<ListQuery>): Promise<Paginated<DataStore>>;
+    /** `GET /v1/datastores/:store`. Scope: `datastores:read`. */
+    get(store: string): Promise<DataStore>;
+    /**
+     * `PATCH /v1/datastores/:store` -- rename, re-point, or both.
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `title` | string | |
+     * | `credentials` | object | Replaced whole, and tested before it is stored. |
+     *
+     * A partial credential is not accepted: send all four fields, or the whole
+     * URI. New credentials go through the same checks as `create`, and the old
+     * connection is dropped -- so the next record call reads from the new cluster
+     * rather than from a connection that happens to still be open.
+     *
+     * Scope: `datastores:write`.
+     */
+    update(store: string, input: UpdateDataStoreInput): Promise<DataStore>;
+    /**
+     * `DELETE /v1/datastores/:store` -- 204.
+     *
+     * Forgets the credential and every schema declared on it. **Your database is
+     * not touched**: the collections and all their documents remain, and
+     * registering the same credential again with the same collection names reads
+     * them straight back.
+     *
+     * Scope: `datastores:write`.
+     */
+    remove(store: string): Promise<void>;
+    /**
+     * `POST /v1/datastores/:store/test` -- connect, and report.
+     *
+     * ```ts
+     * const { ok, database, collections, latencyMs } = await crm.dataStores.test(store.id);
+     * ```
+     *
+     * The answer to "is it us or them". A credential that worked last month may
+     * have been rotated, an Atlas project may be paused, an IP access list may
+     * have been tightened -- each of which this distinguishes by status code
+     * rather than leaving to be inferred from a failing record call.
+     *
+     * `collections` is also what you need in order to point a new schema at a
+     * collection that already exists. It is empty when the database user has no
+     * `listCollections` privilege, which is a perfectly good credential -- not a
+     * sign the database is empty.
+     *
+     * A POST rather than a GET because it opens a connection and updates
+     * `verifiedAt`. Scope: `datastores:read`.
+     */
+    test(store: string): Promise<DataStoreTestResult>;
+}
+/**
+ * The collections you declare over a data store: a name, and the fields in it.
+ *
+ * ```ts
+ * const customers = await crm.dataStoreCollections.create(store.id, {
+ *   title: 'Customers',
+ *   fields: [
+ *     { name: 'Email', type: 'String' },       // stored as `email`
+ *     { name: 'Signed Up', type: 'Date' },     // stored as `signed_up`
+ *     { name: 'Credits', type: 'Number', default: 0 },
+ *     { name: 'Tags', type: 'Array' },
+ *   ],
+ * });
+ *
+ * customers.fields.map((field) => field.name); // ['email','signed_up','credits','tags']
+ * ```
+ *
+ * ## Field names are slugged, once
+ *
+ * The server normalises every name -- punctuation dropped, spaces and hyphens to
+ * underscores, lowercased -- and the normalised name is both what comes back and
+ * what the document actually stores. **Use the returned names as your record
+ * keys.** The legacy panel slugged the name for the database but kept the
+ * original in the schema, so a field called `First Name` stored under
+ * `first_name` while the schema said otherwise, and records written against the
+ * schema's spelling silently went nowhere.
+ *
+ * ## Declaring a collection does not create one
+ *
+ * Mongo creates a collection on its first write, so a new schema addresses a
+ * collection that does not exist yet. Reads against it correctly return an empty
+ * page rather than failing.
+ *
+ * ## Editing fields rewrites nothing
+ *
+ * `update()` changes validation and coercion from the next call onward. It does
+ * not migrate documents: dropping a field hides the values under that key
+ * (re-declare it and they are back), and changing a field's type leaves old
+ * documents holding the old type. The collection a schema points at cannot be
+ * changed at all -- every record ever written through it lives there.
+ */
+export declare class DataStoreCollections {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * `POST /v1/datastores/:store/collections` -- 201.
+     *
+     * | Field | Type | Required | Notes |
+     * | --- | --- | --- | --- |
+     * | `title` | string | yes | 1-120 characters. |
+     * | `fields` | array | yes | 1-100 fields; see below. |
+     * | `collection` | string | no | An existing collection to adopt. Immutable afterwards. |
+     * | `show_in_chat` | boolean | no | Default `false`. Whether the chat panel offers it. |
+     * | `display.theme` | string | no | Presentation only. |
+     * | `display.fields` | string[] | no | Field names to show, in order. Presentation only. |
+     *
+     * **Each field**
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `name` | string | Slugged by the server; the slug is the document key. |
+     * | `type` | `String` `Number` `Boolean` `Date` `Array` | |
+     * | `label` | string | Display only. |
+     * | `default` | string \| number \| boolean | `String`, `Number` and `Boolean` only. |
+     *
+     * Omit `collection` and the server generates `<id>_<slugged title>`, which
+     * cannot collide with anything already in your database. Supply it to point at
+     * a collection you already have -- the way to use a database with data in it
+     * rather than duplicating it.
+     *
+     * | Status | Code | Meaning |
+     * | --- | --- | --- |
+     * | 404 | `not_found` | No such store in this account. |
+     * | 409 | `conflict` | This store already has a schema for that collection name. |
+     * | 422 | `validation_failed` | A field name that slugs to nothing, a duplicate after slugging, or a default of the wrong type. |
+     *
+     * Scope: `datastores:write`.
+     */
+    create(store: string, input: CreateDataStoreCollectionInput): Promise<DataStoreCollection>;
+    /**
+     * `GET /v1/datastores/:store/collections` -- offset paginated,
+     * newest first. `page`, `rows`, and `search` on the title.
+     *
+     * Scope: `datastores:read`.
+     */
+    list(store: string, query?: Partial<ListQuery>): Promise<Paginated<DataStoreCollection>>;
+    /**
+     * `GET /v1/datastores/:store/collections/:collection`.
+     *
+     * Both ids are checked: a collection id belonging to a different store -- even
+     * one of your own -- is a 404 rather than a match.
+     *
+     * Scope: `datastores:read`.
+     */
+    get(store: string, collection: string): Promise<DataStoreCollection>;
+    /**
+     * `PATCH /v1/datastores/:store/collections/:collection`.
+     *
+     * `title`, `fields`, `show_in_chat` and `display`. Not `collection`: a schema
+     * points at one collection for its whole life, and re-pointing it would orphan
+     * every record written through it. Point a new schema at the other collection
+     * instead.
+     *
+     * Scope: `datastores:write`.
+     */
+    update(store: string, collection: string, input: UpdateDataStoreCollectionInput): Promise<DataStoreCollection>;
+    /**
+     * `DELETE /v1/datastores/:store/collections/:collection` -- 204.
+     *
+     * Forgets the declaration. **Your collection and its documents remain** --
+     * declaring the same collection name again reads the same records back.
+     *
+     * Scope: `datastores:write`.
+     */
+    remove(store: string, collection: string): Promise<void>;
+}
+/**
+ * The records in a data store collection -- documents in **your** database.
+ *
+ * ```ts
+ * await crm.dataStoreRecords.insert(store.id, orders.id, {
+ *   records: [{ order_no: 'A-1', total: 10 }, { order_no: 'A-2', total: 20 }],
+ * });
+ *
+ * const { data, pagination } = await crm.dataStoreRecords.search(store.id, orders.id, {
+ *   filter: { paid: false, total: { $gte: 20 } },
+ *   sort: 'total',
+ *   order: 'desc',
+ * });
+ * ```
+ *
+ * ## Writes are validated against the declaration
+ *
+ * Keys must be declared field names, and values are coerced to the declared
+ * type -- `"42"` into a `Number` field is stored as `42`, an ISO string into a
+ * `Date` field as a date. An **undeclared key is a 422 naming it**, which is the
+ * one deliberate break from the legacy endpoint: there, an unknown key was
+ * dropped silently, so a typo meant data quietly went nowhere.
+ *
+ * `null` clears a field. `created_on` and `updated_on` are stamped by the server
+ * -- unix seconds, or real dates if the collection declared them as `Date` --
+ * and ignored if you send them. `id` cannot be written.
+ *
+ * ## Reads return everything that is stored
+ *
+ * Including keys the schema does not declare, because the documents are yours
+ * and may have been written by something else. `_id` reads back as `id`.
+ *
+ * ## There is no aggregation endpoint
+ *
+ * Deliberately: a pipeline can read other collections with `$lookup` and write
+ * them with `$merge`, which would make a schema's boundary meaningless, and
+ * `$function` runs JavaScript on your cluster. The same three operators are
+ * refused inside a filter. For anything that needs a pipeline, use your own
+ * credentials and your own driver -- it is your database.
+ */
+export declare class DataStoreRecords {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records` -- 201.
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `record` | object | One record. Exactly one of this or `records`. |
+     * | `records` | object[] | 1-1000 records. |
+     *
+     * ```ts
+     * const { inserted, ids } = await crm.dataStoreRecords.insert(store, collection, {
+     *   records: rows,
+     * });
+     * ```
+     *
+     * A batch is **unordered**: one document rejected by a unique index of yours
+     * does not abandon the rest, so `inserted` may be lower than what you sent.
+     * `ids` are in the order the documents were sent.
+     *
+     * Prefer one call with `records` over a loop of single inserts -- each call is
+     * a round trip to your cluster.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    insert(store: string, collection: string, input: InsertDataStoreRecordsInput): Promise<DataStoreWriteResult>;
+    /**
+     * `GET /v1/datastores/:store/collections/:collection/records`
+     *
+     * | Query | Type | Default | Notes |
+     * | --- | --- | --- | --- |
+     * | `page` | number | `1` | 1-based. |
+     * | `rows` | number | `25` | 1-100. |
+     * | `sort` | string | `created_on` | Any field name. |
+     * | `order` | `asc` \| `desc` | `desc` | |
+     *
+     * `_id` is appended to the sort as a tiebreaker, so paging is reproducible
+     * even when the sort field repeats -- or does not exist, which it will not on
+     * an adopted collection that something else wrote.
+     *
+     * Scope: `datastore-records:read`.
+     */
+    list(store: string, collection: string, query?: ListDataStoreRecordsQuery): Promise<Paginated<DataStoreRecord>>;
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records/search`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `filter` | object | A Mongo query. Required; `{}` matches everything. |
+     * | `page` `rows` `sort` `order` | | As `list`. |
+     *
+     * ```ts
+     * await crm.dataStoreRecords.search(store, collection, {
+     *   filter: {
+     *     $or: [{ status: 'open' }, { total: { $gte: 100 } }],
+     *     signed_up: { $gte: '2026-01-01' },   // coerced to a Date for a Date field
+     *     tags: 'vip',                         // an Array field contains this
+     *   },
+     * });
+     * ```
+     *
+     * A POST because a Mongo filter is a nested object and encoding one into a
+     * query string is a different argument in every HTTP client. It reads and
+     * changes nothing.
+     *
+     * Operand values are coerced per declared field, so dates and numbers written
+     * as JSON strings match. `$where`, `$function` and `$accumulator` are refused
+     * with `422 filter_operator_not_allowed`, and a filter nested deeper than ten
+     * levels or holding more than 500 keys with `422 filter_too_complex`.
+     *
+     * Scope: `datastore-records:read`.
+     */
+    search(store: string, collection: string, input: SearchDataStoreRecordsInput): Promise<Paginated<DataStoreRecord>>;
+    /**
+     * `GET /v1/datastores/:store/collections/:collection/records/:record`
+     *
+     * 404 when there is no such document. Scope: `datastore-records:read`.
+     */
+    get(store: string, collection: string, record: string): Promise<DataStoreRecord>;
+    /**
+     * `PATCH /v1/datastores/:store/collections/:collection/records/:record`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `record` | object | The fields to change. Validated exactly as an insert. |
+     *
+     * A `$set` of those fields and nothing else -- keys you leave out are
+     * untouched, and `null` clears a value. `updated_on` is stamped; `created_on`
+     * cannot be moved. Returns the record as it is after the write.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    update(store: string, collection: string, record: string, input: UpdateDataStoreRecordInput): Promise<DataStoreRecord>;
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records/bulk-update`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `filter` | object | Required and **non-empty**. |
+     * | `update` | object | The fields to set on every match. |
+     *
+     * ```ts
+     * const { matched, modified } = await crm.dataStoreRecords.bulkUpdate(store, collection, {
+     *   filter: { status: 'pending', created_on: { $lt: cutoff } },
+     *   update: { status: 'expired' },
+     * });
+     * ```
+     *
+     * `{}` as the filter is refused: it matches the whole collection, and a
+     * one-character slip that rewrites every record is not something to make
+     * convenient. `modified` is lower than `matched` where a record already held
+     * the values.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    bulkUpdate(store: string, collection: string, input: BulkUpdateDataStoreRecordsInput): Promise<DataStoreUpdateResult>;
+    /**
+     * `DELETE /v1/datastores/:store/collections/:collection/records/:record`
+     *
+     * 404 when there is no such document. This one really does delete your data.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    remove(store: string, collection: string, record: string): Promise<DataStoreDeleteResult>;
+    /**
+     * `POST /v1/datastores/:store/collections/:collection/records/bulk-delete`
+     *
+     * | Field | Type | Notes |
+     * | --- | --- | --- |
+     * | `filter` | object | Required and **non-empty**. |
+     *
+     * Deletes every match, irreversibly, from your database. The empty filter is
+     * refused for the same reason as in `bulkUpdate` -- emptying a collection
+     * deliberately means paging through it.
+     *
+     * Scope: `datastore-records:write`.
+     */
+    bulkRemove(store: string, collection: string, input: BulkDeleteDataStoreRecordsInput): Promise<DataStoreDeleteResult>;
+}