ab-ecosystem-cpass 1.0.6 → 1.0.8

package/docs/campaign/campaigns.md

@@ -434,56 +434,16 @@ await crm.campaigns.delete(id);
 
 ---
 
-# Campaign reports
+# Reporting
 
-`crm.campaignReports` — `/v1/campaign-reports`
+Campaign reporting lives on its own page: **[campaign messages](campaign-messages.md)**
+— `crm.campaignMessages`.
 
-Delivery metrics for a campaign, rolled up by the platform.
+There is no report collection and no export job. One row is written per attempted
+send, its status is advanced by the channel's delivery webhooks, and every number
+is counted off those rows when you ask for it:
 
 ```ts
-const report = await crm.campaignReports.getByCampaign(campaignId);
-report.metrics;  // { queued, sent, delivered, failed, opened, clicked, unsubscribed }
+const stats = await crm.campaignMessages.stats(id);
+// { total, sent, delivered, read, replied, failed }
 ```
-
-| Action | Route |
-| --- | --- |
-| `list` | `GET /v1/campaign-reports` — cursor-paged, `campaignId` optional |
-| `getByCampaign` | `GET /v1/campaign-reports/:campaignId` |
-
-`getByCampaign` takes an optional window; without it the report covers the
-campaign's whole life:
-
-```ts
-await crm.campaignReports.getByCampaign(campaignId, {
-  from: '2026-10-01T00:00:00.000Z',
-  to: '2026-10-31T23:59:59.000Z',
-});
-```
-
-`generatedAt` is when the metrics were last rolled up, which may lag the
-campaign — a report read seconds after a send will under-count.
-
-## Report exports
-
-`crm.campaignReportExports` — `/v1/campaign-report-exports`
-
-A per-recipient extract, generated asynchronously because it is a file rather
-than a few counters.
-
-```ts
-const job = await crm.campaignReportExports.create({ campaignId, format: 'xlsx' });
-
-// Poll until it finishes, then download.
-const done = await crm.campaignReportExports.get(job.id);
-if (done.status === 'completed') window.location.href = done.fileUrl!;
-```
-
-| Field | Type | Notes |
-| --- | --- | --- |
-| `campaignId` | `string` | required |
-| `format` | `csv` `xlsx` | default `csv` |
-| `from` / `to` | ISO datetime | narrows the rows by period |
-
-`status` moves `queued` → `processing` → `completed` or `failed`; `rowCount` is
-filled in as it goes, and `errorMessage` explains a failure. **`fileUrl` expires**
-— download it rather than storing the link.

package/docs/data-store.md

@@ -0,0 +1,495 @@
+# Data Store
+
+`crm.dataStores`, `crm.dataStoreCollections`, `crm.dataStoreRecords` — `/v1/datastores`
+
+A MongoDB **you** own, registered with the platform. You give it a connection,
+declare the collections and fields you want, and read and write records through
+the API — from a chatbot flow, an automation, or your own code.
+
+This runs as **its own service**, with its own database and its own deployment.
+Nothing else in the platform depends on it, and it depends on nothing else: a
+data store outage leaves contacts, the inbox and campaigns untouched, and the
+connections it holds to customer clusters cannot crowd out anything but itself.
+
+| Resource | Route | Scope |
+| --- | --- | --- |
+| [`dataStores`](#data-stores) | `/v1/datastores` | `datastores:read` / `datastores:write` |
+| [`dataStoreCollections`](#collections) | `…/:store/collections` | `datastores:read` / `datastores:write` |
+| [`dataStoreRecords`](#records) | `…/:store/collections/:collection/records` | `datastore-records:read` / `datastore-records:write` |
+
+## The model
+
+Three things, nested:
+
+```
+data store            a connection to a database you own
+└── collection        a schema: one collection name, and its fields
+    └── records       the documents, in your database
+```
+
+The platform holds **the credential and the schemas, and nothing else**. There
+is no copy of your data here, no mirror and no sync: a record read is a live
+query against your cluster, and a record write lands in it before the response
+comes back.
+
+Two consequences worth holding on to:
+
+- **The platform is not the system of record.** Anything else holding those
+  credentials — your own application, a colleague with Compass — writes the same
+  documents. So a schema here is a *declaration*, not a guarantee: a document
+  may carry fields it never mentioned, or lack ones it does.
+- **Every record call costs a round trip to your database.** The connection
+  stays 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 one `insert` with `records`.
+
+## Deleting never deletes your data
+
+Worth stating before anything else, because the opposite assumption is the
+expensive one:
+
+| Call | What it removes |
+| --- | --- |
+| `dataStores.remove()` | The stored credential, and every schema on it. **Your database is untouched.** |
+| `dataStoreCollections.remove()` | The schema. **Your collection and its documents remain.** |
+| `dataStoreRecords.remove()` / `bulkRemove()` | Documents, from your database, irreversibly. |
+
+Register the same credential again, declare the same collection name, and all of
+it reads straight back. Only the record calls delete anything of yours.
+
+---
+
+## Data stores
+
+### Registering one
+
+```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',
+  },
+});
+```
+
+Or with a connection string, for anything the four fields cannot express — a
+replica-set seed list, a non-standard port, TLS options:
+
+```ts
+await crm.dataStores.create({
+  title: 'Orders DB',
+  credentials: { type: 'string', uri: process.env.ORDERS_DB_URI! },
+});
+```
+
+The URI **must name a database** (`mongodb+srv://user:pass@host/shop`). A URI
+without one is legal Mongo and puts every document in a database called `test`,
+which is a surprising place to find your records a month later, so it is refused
+here instead.
+
+### What happens before the row is written
+
+1. The credential is checked for shape.
+2. The host is resolved, and refused if it resolves somewhere private.
+3. A connection is opened and pinged.
+4. **Only then** is anything stored, with the secret encrypted.
+
+So a `201` means your database really did accept those credentials. A store you
+can see in the list is one that worked at least once.
+
+| Status | Code | Meaning |
+| --- | --- | --- |
+| 422 | `validation_failed` | Malformed URI, a `host` with a scheme in it, no database named. |
+| 422 | `invalid_datastore_host` | The host does not resolve, or resolves to a private address. |
+| 502 | `datastore_auth_failed` | The database refused the username or password. |
+| 502 | `datastore_unreachable` | No answer in time — usually an IP access list. |
+
+### The host has to be reachable from the internet
+
+A credential pointing at a private or loopback address is refused. The platform
+would be connecting to *its own* network rather than to yours, so
+`mongodb://localhost:27017` and `10.x`, `172.16–31.x`, `192.168.x`, `169.254.x`
+are all rejected — including when a hostname you control resolves to one, since
+the check is on the resolved address rather than on the string.
+
+For `mongodb+srv` the SRV record is resolved first and its targets are checked,
+which is also why a missing `_mongodb._tcp` record is reported as a bad host
+rather than as a timeout thirty seconds later.
+
+On Atlas you will usually also need to allow the platform's egress addresses in
+your project's **IP access list**. Without that the symptom is
+`502 datastore_unreachable` with a server-selection timeout, which looks like a
+wrong host but is not.
+
+### No credential ever comes back
+
+```ts
+store.summary;   // 'mongodb+srv://crm_writer:***@cluster0.ab12c.mongodb.net/shop'
+store.host;      // 'cluster0.ab12c.mongodb.net'
+store.username;  // 'crm_writer'
+store.database;  // 'shop'
+```
+
+The password is encrypted at rest and is not returned in any form. `summary` is
+the connection with the password replaced, which is what an edit screen needs in
+order to show which database it is looking at. Host, user and database come back
+in the clear because an edit form has to render them, and none of them opens a
+connection on its own.
+
+### Re-pointing one
+
+```ts
+await crm.dataStores.update(store.id, { title: 'Orders (production)' });
+
+await crm.dataStores.update(store.id, {
+  credentials: { type: 'string', uri: rotatedUri },
+});
+```
+
+Credentials are replaced **whole or not at all**. There is no patching one field
+of them: a host without its matching password is not a weaker credential, it is
+a broken one. New credentials go through the same four steps as a 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.
+
+### Testing one
+
+```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 access list may have been
+tightened — and each of those comes back as a different status code rather than
+being inferred from a failing record call.
+
+`collections` is also what you need to point a new schema at a collection that
+already exists. It is **empty when the database user has no `listCollections`
+privilege** — a least-privilege credential granted only `readWrite` legitimately
+does not have it — so an empty list does not mean an empty database.
+
+---
+
+## Collections
+
+A collection is a schema: one collection name inside your database, and the
+fields it holds.
+
+```ts
+const customers = await crm.dataStoreCollections.create(store.id, {
+  title: 'Customers',
+  fields: [
+    { name: 'Email', type: 'String' },
+    { name: 'Signed Up', type: 'Date' },
+    { name: 'Credits', type: 'Number', default: 0 },
+    { name: 'Tags', type: 'Array' },
+  ],
+});
+
+customers.collection;                       // '68f1c2a39b4e5d6f70812345_customers'
+customers.fields.map((f) => f.name);        // ['email','signed_up','credits','tags']
+```
+
+### Field names are slugged, once
+
+Punctuation is dropped, runs of spaces and hyphens become one underscore, and
+the result is lowercased. `"First Name"` becomes `first_name`.
+
+**Use the names the response gives you as your record keys.** That is the key
+the document actually has. The legacy panel slugged the name when building its
+schema but stored the original, so a field called `First Name` was stored under
+`first_name` while the schema said `First Name` — and a record written against
+the schema's spelling was silently dropped. Here only the slug is ever
+persisted, so the two cannot disagree.
+
+Two names that slug to the same thing (`"First Name"` and `"first_name"`) are
+refused rather than letting the later one quietly win.
+
+### The field types
+
+| Type | Accepts | Notes |
+| --- | --- | --- |
+| `String` | a string; numbers and booleans are stringified | |
+| `Number` | a number, or a numeric string | `NaN` and `Infinity` are refused: nothing compares equal to `NaN`, so a document holding one cannot be found by its own value |
+| `Boolean` | `true`/`false`, `"true"`/`"false"`, `1`/`0` | |
+| `Date` | an ISO string, or a unix timestamp in seconds or milliseconds | Read by magnitude, so both units work |
+| `Array` | an array of anything | Untyped, because the legacy declaration was |
+
+`default` applies when a record omits the field, and only on `String`, `Number`
+and `Boolean`: a `Date` default would have to mean "now", which is a different
+feature, and an `Array` default shared between documents is a trap.
+
+### Pointing at a collection you already have
+
+```ts
+const existing = await crm.dataStoreCollections.create(store.id, {
+  title: 'Orders',
+  collection: 'orders',   // the collection already in your database
+  fields: [{ name: 'order_no', type: 'String' }, { name: 'total', type: 'Number' }],
+});
+```
+
+Omit `collection` and the server generates `<schema id>_<slugged title>`, which
+cannot collide with anything already there. Supply it and the schema reads and
+writes a collection you already have — which is how a database with data in it
+gets used rather than duplicated. `dataStores.test()` lists the names.
+
+It is **immutable afterwards**, and `update()` does not accept it. A schema
+points at one collection for its whole life: every record ever written through
+it lives there, and re-pointing it would orphan all of them. Point a *new*
+schema at the other collection instead.
+
+One schema per collection name per store, enforced by a unique index — two
+schemas over one collection with different field declarations would mean a
+record validating or not depending on which one it was written through.
+
+### Declaring a collection does not create one
+
+Mongo creates a collection on its first write. So a brand new schema addresses a
+collection that is not there yet, and reads against it correctly return an empty
+page rather than failing.
+
+### Editing fields rewrites nothing
+
+```ts
+await crm.dataStoreCollections.update(store.id, customers.id, {
+  fields: [...customers.fields, { name: 'plan', type: 'String', default: 'free' }],
+});
+```
+
+`fields` replaces the whole list, and takes effect from the next call onward. It
+does not migrate anything:
+
+- **Dropping a field** stops it being writable and does not delete the data
+  under that key. Re-declare the field and the values are there again.
+- **Changing a type** leaves existing documents holding the old type. A
+  `Number` field that used to be a `String` reads back strings for old records
+  and numbers for new ones.
+- **Adding a default** does not backfill. It applies to records inserted after.
+
+---
+
+## Records
+
+Documents in your database.
+
+```ts
+await crm.dataStoreRecords.insert(store.id, customers.id, {
+  record: { email: 'a@example.com', signed_up: '2026-10-14T09:00:00Z', tags: ['vip'] },
+});
+
+await crm.dataStoreRecords.insert(store.id, customers.id, {
+  records: rows,   // up to 1000
+});
+```
+
+### 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 real date.
+
+An **undeclared key is a 422 that names it**:
+
+```json
+{
+  "error": {
+    "code": "validation_failed",
+    "details": {
+      "fieldErrors": {
+        "unknown_fields": ["Not declared on this collection: emial. Declared fields are: email, signed_up, credits, tags"]
+      }
+    }
+  }
+}
+```
+
+This is the one deliberate break from the legacy endpoint. There, a mongoose
+schema with `strict: true` *dropped* unknown keys, so a record posted with
+`emial` returned success having stored nothing under either spelling — and
+nobody noticed for as long as nobody went looking.
+
+| Key | On the way in |
+| --- | --- |
+| a declared field | coerced to its type |
+| `null` | clears the field |
+| `created_on`, `updated_on` | ignored — the server stamps them |
+| `id`, `_id` | refused: the database assigns the id |
+| anything else | **422**, naming it |
+
+`created_on` and `updated_on` are unix **seconds**, or real `Date`s if the
+collection declared them with `type: 'Date'`. `created_on` is written once;
+`updated_on` moves on every update, and an update cannot move `created_on`.
+
+### Inserting many
+
+```ts
+const { inserted, ids } = await crm.dataStoreRecords.insert(store.id, orders.id, {
+  records: rows,
+});
+```
+
+A batch is **unordered**: one document rejected by a unique index of yours does
+not abandon the rest, so `inserted` can be lower than what you sent. `ids` come
+back in the order the documents went out.
+
+### Reading
+
+```ts
+const { data, pagination } = await crm.dataStoreRecords.list(store.id, orders.id, {
+  rows: 50,
+  sort: 'total',
+  order: 'desc',
+});
+```
+
+| Query | Default | Notes |
+| --- | --- | --- |
+| `page` | `1` | 1-based. |
+| `rows` | `25` | 1–100. |
+| `sort` | `created_on` | Any field name. |
+| `order` | `desc` | |
+
+`_id` is appended to the sort as a tiebreaker, so paging is reproducible even
+when the sort field repeats — or does not exist at all, which it will not on an
+adopted collection something else wrote. Without that, offset paging over tied
+values can return the same document on two pages and skip another entirely.
+
+**Reads return every stored key**, declared or not. The documents are yours and
+may have been written by something else; hiding your own data because our
+declaration is incomplete would be worse than surprising. `_id` reads back as
+`id`, and dates as ISO strings.
+
+### Searching
+
+```ts
+const { data } = await crm.dataStoreRecords.search(store.id, orders.id, {
+  filter: {
+    $or: [{ status: 'open' }, { total: { $gte: 100 } }],
+    created_on: { $gte: '2026-10-01' },
+    tags: 'vip',
+  },
+  sort: 'total',
+  order: 'desc',
+});
+```
+
+A real Mongo filter — `$in`, `$gt`, `$or`, `$nor`, `$not`, `$regex`, `$exists`,
+`$elemMatch`, all of it. It is your database: there is nothing in it you do not
+already own, so narrowing the query language would only cost you expressiveness.
+
+A POST rather than a GET 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.
+
+**Operands are coerced per declared field** before the query is sent, which is
+the difference between a filter that works and one that silently matches
+nothing:
+
+| Filter | Against | What is actually sent |
+| --- | --- | --- |
+| `{ created_on: { $gte: '2026-10-01' } }` | a `Date` field | a real `Date` |
+| `{ total: { $gt: '100' } }` | a `Number` field | `100` |
+| `{ id: '68f1c2…' }` | — | `{ _id: ObjectId('68f1c2…') }` |
+| `{ tags: 'vip' }` | an `Array` field | unchanged — "contains" |
+
+`id` works as an alias for `_id` and takes the string form, because `id` is the
+name every record reads back with.
+
+Three operators are refused wherever they appear, at any depth:
+
+| Status | Code | Meaning |
+| --- | --- | --- |
+| 422 | `filter_operator_not_allowed` | `$where`, `$function` or `$accumulator` — each runs JavaScript on your cluster. |
+| 422 | `filter_too_complex` | Nested deeper than 10 levels, or more than 500 keys. |
+| 422 | `validation_failed` | An operand that cannot be coerced — `{ total: { $gt: 'abc' } }` on a `Number` field. |
+
+A value that cannot be coerced is reported rather than quietly matching nothing.
+
+### Updating
+
+```ts
+await crm.dataStoreRecords.update(store.id, orders.id, record.id, {
+  record: { status: 'shipped', tracking: 'XY123' },
+});
+```
+
+A `$set` of those fields and nothing else. Keys you leave out are untouched,
+`null` clears a value, and the response is the record as it is after the write.
+Validation is identical to an insert.
+
+There is no `$inc`, `$push` or `$rename`: an update here is "these fields now
+have these values", which is what every caller of the legacy endpoint was doing
+— it wrapped the body in `$set` too — and it keeps an update subject to the same
+field validation as an insert.
+
+### Bulk update and delete
+
+```ts
+const { matched, modified } = await crm.dataStoreRecords.bulkUpdate(store.id, orders.id, {
+  filter: { status: 'pending', created_on: { $lt: cutoff } },
+  update: { status: 'expired' },
+});
+
+const { deleted } = await crm.dataStoreRecords.bulkRemove(store.id, orders.id, {
+  filter: { status: 'expired' },
+});
+```
+
+**The filter cannot be empty.** `{}` matches the whole collection, and a
+one-character slip that rewrites or deletes every record is not something to
+make convenient — emptying a collection deliberately means paging through it.
+
+`modified` is lower than `matched` where a record already held the values being
+written, which is worth seeing rather than collapsing into one number.
+
+---
+
+## Isolation
+
+Records carry no tenant field. They are not ours to stamp — they are documents
+in your database, often ones that existed before you registered it.
+
+So isolation is the **resolution order**, and it is the same on every record
+call:
+
+1. The store is resolved inside the calling account.
+2. The collection is resolved inside that store.
+3. Only then is a connection acquired and a query sent.
+
+A store id from another account is a `404`. A collection id from another store —
+including another of your own — is a `404`. Never a `403`: that would confirm
+the id exists.
+
+## Connections
+
+One connection per distinct credential, shared by every request using it, with a
+small driver pool inside it. Idle connections close after ten minutes and the
+least recently used one closes when the cache is full; both are invisible to
+callers, since the next call reconnects.
+
+This is worth knowing for one reason: the platform holds open connections to
+your cluster while you are using it. They count against your Atlas connection
+limit, alongside your own applications. The per-credential pool is deliberately
+small for that reason.
+
+The legacy implementation opened a **new connection for every single
+operation** and closed it afterwards — a TCP handshake, a TLS handshake, a SCRAM
+exchange and two DNS lookups before each query, and nothing bounding how many
+existed at once. A busy flow could exhaust a customer's own connection limit.
+
+## Not here
+
+- **No aggregation.** A pipeline can read other collections with `$lookup` and
+  write them with `$merge`, which makes a schema's boundary meaningless, and
+  `$function` runs JavaScript on your cluster. Use your own credentials and your
+  own driver for that — it is your database.
+- **No index management.** Create indexes on your own cluster. Any unique index
+  you create is enforced on writes through this API, and a violation comes back
+  as a `422` quoting the database's own message.
+- **No bulk import from a file.** `insert` with `records` is the batch path,
+  1000 at a time.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ab-ecosystem-cpass",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "JavaScript/TypeScript SDK for the CPaaS CRM gateway: audience and channels",
   "license": "MIT",
   "main": "dist/index.js",

package/dist/resources/campaign-report-exports.d.ts

@@ -1,14 +0,0 @@
-import type { CampaignReportExport, CreateCampaignReportExportInput } from '../types/campaign';
-import type { Page, PageQuery } from '../types/common';
-import type { HttpClient } from '../http';
-export declare class CampaignReportExports {
-    private readonly http;
-    constructor(http: HttpClient);
-    list(query?: Partial<PageQuery>): Promise<Page<CampaignReportExport>>;
-    /**
-     * One export. Poll this until `status` is `completed`, then read `fileUrl` --
-     * which expires, so download rather than storing the link.
-     */
-    get(id: string): Promise<CampaignReportExport>;
-    create(input: CreateCampaignReportExportInput): Promise<CampaignReportExport>;
-}

package/dist/resources/campaign-report-exports.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CampaignReportExports = void 0;
-class CampaignReportExports {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    list(query = {}) {
-        return this.http.request('GET', '/v1/campaign-report-exports', {
-            query,
-        });
-    }
-    /**
-     * One export. Poll this until `status` is `completed`, then read `fileUrl` --
-     * which expires, so download rather than storing the link.
-     */
-    get(id) {
-        return this.http.request('GET', `/v1/campaign-report-exports/${encodeURIComponent(id)}`);
-    }
-    create(input) {
-        return this.http.request('POST', '/v1/campaign-report-exports', {
-            body: input,
-        });
-    }
-}
-exports.CampaignReportExports = CampaignReportExports;
-//# sourceMappingURL=campaign-report-exports.js.map

package/dist/resources/campaign-report-exports.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"campaign-report-exports.js","sourceRoot":"","sources":["../../src/resources/campaign-report-exports.ts"],"names":[],"mappings":";;;AAIA,MAAa,qBAAqB;IACH;IAA7B,YAA6B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAEjD,IAAI,CAAC,QAA4B,EAAE;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAA6B,KAAK,EAAE,6BAA6B,EAAE;YACzF,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CACtB,KAAK,EACL,+BAA+B,kBAAkB,CAAC,EAAE,CAAC,EAAE,CACxD,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,KAAsC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAuB,MAAM,EAAE,6BAA6B,EAAE;YACpF,IAAI,EAAE,KAAK;SACZ,CAAC,CAAC;IACL,CAAC;CACF;AAzBD,sDAyBC"}

package/dist/resources/campaign-reports.d.ts

@@ -1,15 +0,0 @@
-import type { CampaignReport, GetCampaignReportQuery } from '../types/campaign';
-import type { Page, PageQuery } from '../types/common';
-import type { HttpClient } from '../http';
-export declare class CampaignReports {
-    private readonly http;
-    constructor(http: HttpClient);
-    list(query?: Partial<PageQuery>): Promise<Page<CampaignReport>>;
-    /**
-     * The report for one campaign.
-     *
-     * `from`/`to` narrow the window the metrics are rolled up over; without them
-     * the report covers the campaign's whole life.
-     */
-    getByCampaign(campaignId: string, query?: GetCampaignReportQuery): Promise<CampaignReport>;
-}

package/dist/resources/campaign-reports.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CampaignReports = void 0;
-class CampaignReports {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    list(query = {}) {
-        return this.http.request('GET', '/v1/campaign-reports', { query });
-    }
-    /**
-     * The report for one campaign.
-     *
-     * `from`/`to` narrow the window the metrics are rolled up over; without them
-     * the report covers the campaign's whole life.
-     */
-    getByCampaign(campaignId, query = {}) {
-        return this.http.request('GET', `/v1/campaign-reports/${encodeURIComponent(campaignId)}`, {
-            query,
-        });
-    }
-}
-exports.CampaignReports = CampaignReports;
-//# sourceMappingURL=campaign-reports.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"campaign-reports.js","sourceRoot":"","sources":["../../src/resources/campaign-reports.ts"],"names":[],"mappings":";;;AAIA,MAAa,eAAe;IACG;IAA7B,YAA6B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAEjD,IAAI,CAAC,QAA4B,EAAE;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAuB,KAAK,EAAE,sBAAsB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3F,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAC,UAAkB,EAAE,QAAgC,EAAE;QAClE,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAiB,KAAK,EAAE,wBAAwB,kBAAkB,CAAC,UAAU,CAAC,EAAE,EAAE;YACxG,KAAK;SACN,CAAC,CAAC;IACL,CAAC;CACF;AAlBD,0CAkBC"}