@allisall/sdk 0.1.0 → 0.4.0

package/dist/resources/clients.js

@@ -0,0 +1,113 @@
+// The `clients` operations.
+import { call, callPage } from "../request.js";
+/** The `clients` operations. */
+export class Clients {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Lists clients. Await the result for one page; iterate it with
+     * `for await` for every client of every page.
+     *
+     * Pass `page` for a numbered page: its `body` then holds `page` and
+     * `total`. Only that first page is counted; every later page of a walk
+     * continues by cursor from it, and its `page` and `total` are `null`. To
+     * show another numbered page, call this method again with its `page`
+     * rather than `getNextPage()`. A `page` past the end has no items, and the
+     * walk ends there.
+     *
+     * Needs the `read` scope. Operation `listClients`.
+     */
+    list(query, options) {
+        return callPage(this.#config, "listClients", { query, options });
+    }
+    /**
+     * Creates a client.
+     *
+     * A `renewal_date` before the request's UTC date less one day is refused
+     * with `400` `out_of_range`, so no time zone's today is refused. With a
+     * `renewal_term`, an active client's renewal date rolls forward by whole
+     * terms once it passes.
+     *
+     * `client_key` is unique in the workspace, ignoring letter case and
+     * surrounding whitespace: a key another client already holds, in any
+     * case or padding, is refused with `409` `client_key_in_use`.
+     *
+     * Every attempt of the call sends one `Idempotency-Key`, so a retry
+     * cannot create a second client.
+     *
+     * Needs the `write` scope. Operation `createClient`.
+     */
+    create(body, options) {
+        return call(this.#config, "createClient", { body, options });
+    }
+    /**
+     * Reads a client.
+     *
+     * Needs the `read` scope. Operation `getClient`.
+     */
+    get(id, options) {
+        return call(this.#config, "getClient", { path: { id }, options });
+    }
+    /**
+     * Updates a client with a merge patch: a member left out keeps its
+     * value, `null` clears it, and any other value sets it.
+     *
+     * Sending back the `renewal_date` a read returned keeps the client's
+     * renewal schedule: a date on the schedule, up to the one it shows on the
+     * next UTC day, changes nothing. Any other date is a new renewal date, and
+     * one before the request's UTC date less one day is refused with `400`
+     * `out_of_range`. A patch that changes `renewal_term` or `status` saves
+     * the date the client shows on the current UTC day as the new start of
+     * its schedule, without the patch sending a date.
+     *
+     * `client_key` is unique in the workspace, ignoring letter case and
+     * surrounding whitespace: a key another client already holds, in any
+     * case or padding, is refused with `409` `client_key_in_use`.
+     *
+     * Never retried.
+     *
+     * Needs the `write` scope. Operation `updateClient`.
+     */
+    update(id, patch, options) {
+        return call(this.#config, "updateClient", {
+            path: { id },
+            body: patch,
+            options,
+        });
+    }
+    /**
+     * Deletes a client. Refused while events carry the client's key, or
+     * while the client has a validated or published calculation; set its
+     * status to `churned` instead.
+     *
+     * A retry after a lost response can answer `404` for a delete that
+     * succeeded.
+     *
+     * Needs the `write` scope. Operation `deleteClient`.
+     */
+    delete(id, options) {
+        return call(this.#config, "deleteClient", { path: { id }, options });
+    }
+    /**
+     * Replaces a client's assigned agents. Assignment decides how later
+     * events are attributed: an event without `client_key` from an agent
+     * assigned to exactly one client is attributed to that client. A
+     * `model` or `outcome` event from an agent assigned to two or more
+     * clients must carry `client_key`, or it is refused with
+     * `client_key_required`.
+     *
+     * Retried on a failure worth retrying, because a repeat leaves the same
+     * agents assigned.
+     *
+     * Needs the `write` scope. Operation `setClientAgents`.
+     */
+    setAgents(id, body, options) {
+        return call(this.#config, "setClientAgents", {
+            path: { id },
+            body,
+            options,
+        });
+    }
+}

package/dist/resources/cost.d.ts

@@ -0,0 +1,76 @@
+import type { MoneyInput } from "../money.js";
+import type { IdempotentRequestOptions, RequestOptions } from "../options.js";
+import type { PagePromise } from "../pagination.js";
+import type { TransportConfig } from "../transport.js";
+import type { CostLineItem, CostLineItemCreate, CostLineItemList, CostLineItemPatch, ListCostLineItemsQuery, PriceTable, PriceTableSet } from "../types.js";
+/** The `cost` operations. */
+export declare class Cost {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Lists cost line items. Await the result for one page; iterate it with
+     * `for await` for every line item of every page.
+     *
+     * Pass `page` for a numbered page: its `body` then holds `page` and
+     * `total`. Only that first page is counted; every later page of a walk
+     * continues by cursor from it, and its `page` and `total` are `null`. To
+     * show another numbered page, call this method again with its `page`
+     * rather than `getNextPage()`. A `page` past the end has no items, and the
+     * walk ends there.
+     *
+     * Needs the `read` scope. Operation `listCostLineItems`.
+     */
+    listLineItems(query?: ListCostLineItemsQuery, options?: RequestOptions): PagePromise<CostLineItem, CostLineItemList>;
+    /**
+     * Creates a cost line item. `monthly_amount` takes a `Decimal` or a
+     * `number`.
+     *
+     * Every attempt of the call sends one `Idempotency-Key`, so a retry
+     * cannot create a second line item.
+     *
+     * Needs the `write` scope. Operation `createCostLineItem`.
+     */
+    createLineItem(body: MoneyInput<CostLineItemCreate>, options?: IdempotentRequestOptions): Promise<CostLineItem>;
+    /**
+     * Reads a cost line item.
+     *
+     * Needs the `read` scope. Operation `getCostLineItem`.
+     */
+    getLineItem(id: string, options?: RequestOptions): Promise<CostLineItem>;
+    /**
+     * Updates a cost line item with a merge patch: a member left out keeps
+     * its value, `null` clears it, and any other value sets it.
+     * `monthly_amount` takes a `Decimal` or a `number`.
+     *
+     * Never retried.
+     *
+     * Needs the `write` scope. Operation `updateCostLineItem`.
+     */
+    updateLineItem(id: string, patch: MoneyInput<CostLineItemPatch>, options?: RequestOptions): Promise<CostLineItem>;
+    /**
+     * Deletes a cost line item.
+     *
+     * A retry after a lost response can answer `404` for a delete that
+     * succeeded.
+     *
+     * Needs the `write` scope. Operation `deleteCostLineItem`.
+     */
+    deleteLineItem(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Reads the price table.
+     *
+     * Needs the `read` scope. Operation `getPriceTable`.
+     */
+    getPriceTable(options?: RequestOptions): Promise<PriceTable>;
+    /**
+     * Replaces the price table, as a whole. Each rate takes a `Decimal` or a
+     * `number`, so a table read with `getPriceTable` can be sent back as it
+     * is.
+     *
+     * Retried on a failure worth retrying, because a repeat leaves the same
+     * price table.
+     *
+     * Needs the `write` scope. Operation `setPriceTable`.
+     */
+    setPriceTable(body: MoneyInput<PriceTableSet>, options?: RequestOptions): Promise<PriceTable>;
+}

package/dist/resources/cost.js

@@ -0,0 +1,96 @@
+// The `cost` operations: cost line items and the price table.
+import { call, callPage } from "../request.js";
+/** The `cost` operations. */
+export class Cost {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Lists cost line items. Await the result for one page; iterate it with
+     * `for await` for every line item of every page.
+     *
+     * Pass `page` for a numbered page: its `body` then holds `page` and
+     * `total`. Only that first page is counted; every later page of a walk
+     * continues by cursor from it, and its `page` and `total` are `null`. To
+     * show another numbered page, call this method again with its `page`
+     * rather than `getNextPage()`. A `page` past the end has no items, and the
+     * walk ends there.
+     *
+     * Needs the `read` scope. Operation `listCostLineItems`.
+     */
+    listLineItems(query, options) {
+        return callPage(this.#config, "listCostLineItems", { query, options });
+    }
+    /**
+     * Creates a cost line item. `monthly_amount` takes a `Decimal` or a
+     * `number`.
+     *
+     * Every attempt of the call sends one `Idempotency-Key`, so a retry
+     * cannot create a second line item.
+     *
+     * Needs the `write` scope. Operation `createCostLineItem`.
+     */
+    createLineItem(body, options) {
+        return call(this.#config, "createCostLineItem", { body, options });
+    }
+    /**
+     * Reads a cost line item.
+     *
+     * Needs the `read` scope. Operation `getCostLineItem`.
+     */
+    getLineItem(id, options) {
+        return call(this.#config, "getCostLineItem", { path: { id }, options });
+    }
+    /**
+     * Updates a cost line item with a merge patch: a member left out keeps
+     * its value, `null` clears it, and any other value sets it.
+     * `monthly_amount` takes a `Decimal` or a `number`.
+     *
+     * Never retried.
+     *
+     * Needs the `write` scope. Operation `updateCostLineItem`.
+     */
+    updateLineItem(id, patch, options) {
+        return call(this.#config, "updateCostLineItem", {
+            path: { id },
+            body: patch,
+            options,
+        });
+    }
+    /**
+     * Deletes a cost line item.
+     *
+     * A retry after a lost response can answer `404` for a delete that
+     * succeeded.
+     *
+     * Needs the `write` scope. Operation `deleteCostLineItem`.
+     */
+    deleteLineItem(id, options) {
+        return call(this.#config, "deleteCostLineItem", {
+            path: { id },
+            options,
+        });
+    }
+    /**
+     * Reads the price table.
+     *
+     * Needs the `read` scope. Operation `getPriceTable`.
+     */
+    getPriceTable(options) {
+        return call(this.#config, "getPriceTable", { options });
+    }
+    /**
+     * Replaces the price table, as a whole. Each rate takes a `Decimal` or a
+     * `number`, so a table read with `getPriceTable` can be sent back as it
+     * is.
+     *
+     * Retried on a failure worth retrying, because a repeat leaves the same
+     * price table.
+     *
+     * Needs the `write` scope. Operation `setPriceTable`.
+     */
+    setPriceTable(body, options) {
+        return call(this.#config, "setPriceTable", { body, options });
+    }
+}

package/dist/resources/dashboard.d.ts

@@ -0,0 +1,32 @@
+import type { RequestOptions } from "../options.js";
+import type { PagePromise } from "../pagination.js";
+import type { TransportConfig } from "../transport.js";
+import type { Dashboard, GetDashboardQuery, ListRenewalsQuery, Renewal, RenewalList } from "../types.js";
+/** The `dashboard` operations. */
+export declare class DashboardOperations {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Reads the workspace's month: its published figures for the calendar
+     * month `month`, such as `2026-08`, which is required.
+     *
+     * Needs the `read` scope. Operation `getDashboard`.
+     */
+    get(query: GetDashboardQuery, options?: RequestOptions): Promise<Dashboard>;
+    /**
+     * Lists renewal readiness: each client's latest published figures,
+     * whatever month `get` reads. Await the result for one page; iterate it
+     * with `for await` for every client of every page.
+     *
+     * `today` is the date renewal dates are rolled against and `window` is
+     * measured from; left out, it is the current UTC date, which the response
+     * echoes. A walk sends the first page's `today` on every later page, so it
+     * reads one date even across midnight UTC; to page by number instead,
+     * send that `today` yourself with each `page`. `renewal_term` takes an
+     * array, sent as one parameter per item; an empty array is refused
+     * before sending, because leaving it out means every term.
+     *
+     * Needs the `read` scope. Operation `listRenewals`.
+     */
+    listRenewals(query?: ListRenewalsQuery, options?: RequestOptions): PagePromise<Renewal, RenewalList>;
+}

package/dist/resources/dashboard.js

@@ -0,0 +1,36 @@
+// The `dashboard` operations.
+import { call, callPage } from "../request.js";
+/** The `dashboard` operations. */
+export class DashboardOperations {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Reads the workspace's month: its published figures for the calendar
+     * month `month`, such as `2026-08`, which is required.
+     *
+     * Needs the `read` scope. Operation `getDashboard`.
+     */
+    get(query, options) {
+        return call(this.#config, "getDashboard", { query, options });
+    }
+    /**
+     * Lists renewal readiness: each client's latest published figures,
+     * whatever month `get` reads. Await the result for one page; iterate it
+     * with `for await` for every client of every page.
+     *
+     * `today` is the date renewal dates are rolled against and `window` is
+     * measured from; left out, it is the current UTC date, which the response
+     * echoes. A walk sends the first page's `today` on every later page, so it
+     * reads one date even across midnight UTC; to page by number instead,
+     * send that `today` yourself with each `page`. `renewal_term` takes an
+     * array, sent as one parameter per item; an empty array is refused
+     * before sending, because leaving it out means every term.
+     *
+     * Needs the `read` scope. Operation `listRenewals`.
+     */
+    listRenewals(query, options) {
+        return callPage(this.#config, "listRenewals", { query, options });
+    }
+}

package/dist/resources/events.d.ts

@@ -0,0 +1,116 @@
+import type { RequestOptions } from "../options.js";
+import type { PagePromise } from "../pagination.js";
+import { type TransportConfig } from "../transport.js";
+import type { AttributedEvent, ClientEventList, EventArrivalList, EventInput, EventList, EventSummary, GetEventSummaryQuery, IngestSummary, ListClientEventsQuery, ListEventArrivalsQuery, ListEventsQuery } from "../types.js";
+/** The `events` operations. */
+export declare class Events {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Ingests any number of events. They are sent in batches of at most 500
+     * events and 4,000,000 bytes, one batch after another, each retried as
+     * the client allows. Every event without an `event_id` gets a generated
+     * one, so a retry never stores an event twice. Your objects are not
+     * modified.
+     *
+     * An event too large to send even alone is not sent, and is reported as a
+     * rejected row with the code `too_large`.
+     *
+     * @returns the combined outcome over the whole list.
+     * @throws {IngestError} when a batch fails; the call stops there, and the
+     * error carries the summary so far and every event from the failed batch
+     * onward, to send again. A batch fails on an error response, on no
+     * response, on the caller's cancellation, or when its token cannot be
+     * had: an error from `tokenProvider`, or, in a browser without
+     * `dangerouslyAllowBrowser`, a provider's token that is an API key. The
+     * error is the `IngestError`'s `cause`.
+     * @throws {TypeError} when an event cannot be encoded, or `options.headers`
+     * names a header the SDK sets, before anything is sent.
+     * @throws {AllisallError} when `options.timeout` or `options.maxRetries` is
+     * one the client would refuse, before anything is sent.
+     */
+    ingest(events: readonly EventInput[], options?: RequestOptions): Promise<IngestSummary>;
+    /**
+     * Lists the workspace's events whose `timestamp` falls in the period,
+     * newest first. Await the result for one page; iterate it with
+     * `for await` for every event of every page.
+     *
+     * `from` and `to` are required unless `import_batch_id` is sent, and
+     * then are both sent or neither; the API refuses a missing bound with
+     * `required`. The type cannot say so, so both are optional in it.
+     *
+     * The list is held still under an arrival limit, `as_of`, which the first
+     * response issues. A walk follows `next_cursor`, which carries it, so
+     * every page of one walk reads the same events while new ones arrive. To
+     * show numbered pages instead, send the first response's `as_of` with each
+     * later `page`. Filtered by `import_batch_id`, `as_of` is issued but not
+     * applied, because an import's events appear together when it commits.
+     * Otherwise an event appears a second or two after the API stores it, and
+     * later while a long request, such as a large import, is still in
+     * progress, so a read straight after an ingest may not include it yet.
+     *
+     * Pass `page` for a numbered page: its `body` then holds `page`, `total`
+     * and `total_capped`. `total` counts at most 10,000 events, and
+     * `total_capped` is `true` when more matched; filtered by
+     * `import_batch_id`, `total` is exact. Only that first page is counted;
+     * every later page of a walk continues by cursor from it, and its `page`,
+     * `total` and `total_capped` are `null`. To show another numbered page,
+     * call this method again with its `page` rather than `getNextPage()`.
+     *
+     * `sort` and `dir` other than `timestamp` descending need `page`, or the
+     * API refuses the call with `required` on `page`. A walk from a sorted
+     * page continues by offset and reads every earlier row for each page, so
+     * walk in the default order.
+     *
+     * Needs the `read` scope. Operation `listEvents`.
+     */
+    list(query?: ListEventsQuery, options?: RequestOptions): PagePromise<AttributedEvent, EventList>;
+    /**
+     * Counts the events `list` holds under the same period, filters and
+     * `as_of`: in all, per day and per category. A day is 24 hours counted
+     * from `from`, so local midnight with its offset as `from` gives local
+     * days. The period is required, also with `import_batch_id`. Without
+     * `import_batch_id`, an event is counted a second or two after the API
+     * stores it, and later while a long request, such as a large import, is
+     * still in progress, so a read straight after an ingest may not count it
+     * yet.
+     *
+     * Needs the `read` scope. Operation `getEventSummary`.
+     */
+    getSummary(query: GetEventSummaryQuery, options?: RequestOptions): Promise<EventSummary>;
+    /**
+     * Lists the workspace's events in the order the API stored them, newest
+     * first, below an arrival limit, `as_of`, which the response issues.
+     * Await the result for one page; iterate it with `for await` for every
+     * event of every page. `from` and `to` filter by `timestamp`, and each is
+     * optional on its own.
+     *
+     * With `since`, the list holds the events that arrived at or after it, and
+     * `body.count` counts them. To poll, send each response's `as_of` as the
+     * next call's `since` and walk the result: consecutive windows meet
+     * without a gap or an overlap. To learn only how many arrived, pass a
+     * `limit` of 1 and read `body.count`. The SDK does not poll on its own.
+     * `since` may be at most 24 hours back; a feed further behind reloads
+     * without it. An event falls below `as_of` a second or two after the API
+     * stores it, and later while a long request, such as a large import, is
+     * still in progress. A read straight after an ingest may not include it
+     * yet; poll with `since` until it does.
+     *
+     * Needs the `read` scope. Operation `listEventArrivals`.
+     */
+    listArrivals(query?: ListEventArrivalsQuery, options?: RequestOptions): PagePromise<AttributedEvent, EventArrivalList>;
+    /**
+     * Lists the events behind a client's totals: the event drill-down, over
+     * the period `from` to `to`.
+     *
+     * Pass `page` or `cursor`, not both; neither means page 1. A `page`
+     * beyond the end returns no rows and the true `total`. Await the result
+     * for one page, whose `body` holds `total` and `period`; iterate it with
+     * `for await` for every event of every page from there.
+     *
+     * Needs the `read` scope. Operation `listClientEvents`.
+     *
+     * @param clientId - the client's id.
+     */
+    listForClient(clientId: string, query: ListClientEventsQuery, options?: RequestOptions): PagePromise<AttributedEvent, ClientEventList>;
+}

package/dist/resources/events.js

@@ -0,0 +1,145 @@
+// The `events` operations: ingest, the workspace's events, their summary
+// and arrivals, and the event drill-down.
+import { OPERATIONS } from "../generated/operations.js";
+import { ingest, readIngestResult } from "../ingest.js";
+import { call, callPage, policyOf } from "../request.js";
+import { post } from "../transport.js";
+/** The `events` operations. */
+export class Events {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Ingests any number of events. They are sent in batches of at most 500
+     * events and 4,000,000 bytes, one batch after another, each retried as
+     * the client allows. Every event without an `event_id` gets a generated
+     * one, so a retry never stores an event twice. Your objects are not
+     * modified.
+     *
+     * An event too large to send even alone is not sent, and is reported as a
+     * rejected row with the code `too_large`.
+     *
+     * @returns the combined outcome over the whole list.
+     * @throws {IngestError} when a batch fails; the call stops there, and the
+     * error carries the summary so far and every event from the failed batch
+     * onward, to send again. A batch fails on an error response, on no
+     * response, on the caller's cancellation, or when its token cannot be
+     * had: an error from `tokenProvider`, or, in a browser without
+     * `dangerouslyAllowBrowser`, a provider's token that is an API key. The
+     * error is the `IngestError`'s `cause`.
+     * @throws {TypeError} when an event cannot be encoded, or `options.headers`
+     * names a header the SDK sets, before anything is sent.
+     * @throws {AllisallError} when `options.timeout` or `options.maxRetries` is
+     * one the client would refuse, before anything is sent.
+     */
+    ingest(events, options = {}) {
+        const config = this.#config;
+        let policy;
+        try {
+            policy = policyOf(config, "ingestEvents", OPERATIONS.ingestEvents, options);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        // Each batch has its own signal; ingest is always eligible for a retry,
+        // because event_id deduplicates, which post() sets.
+        const { timeout, maxRetries, headers } = policy;
+        return ingest(events, (body, count, signal) => post(config, OPERATIONS.ingestEvents.path, body, (value) => readIngestResult(value, count), { timeout, maxRetries, headers, signal }), options.signal);
+    }
+    /**
+     * Lists the workspace's events whose `timestamp` falls in the period,
+     * newest first. Await the result for one page; iterate it with
+     * `for await` for every event of every page.
+     *
+     * `from` and `to` are required unless `import_batch_id` is sent, and
+     * then are both sent or neither; the API refuses a missing bound with
+     * `required`. The type cannot say so, so both are optional in it.
+     *
+     * The list is held still under an arrival limit, `as_of`, which the first
+     * response issues. A walk follows `next_cursor`, which carries it, so
+     * every page of one walk reads the same events while new ones arrive. To
+     * show numbered pages instead, send the first response's `as_of` with each
+     * later `page`. Filtered by `import_batch_id`, `as_of` is issued but not
+     * applied, because an import's events appear together when it commits.
+     * Otherwise an event appears a second or two after the API stores it, and
+     * later while a long request, such as a large import, is still in
+     * progress, so a read straight after an ingest may not include it yet.
+     *
+     * Pass `page` for a numbered page: its `body` then holds `page`, `total`
+     * and `total_capped`. `total` counts at most 10,000 events, and
+     * `total_capped` is `true` when more matched; filtered by
+     * `import_batch_id`, `total` is exact. Only that first page is counted;
+     * every later page of a walk continues by cursor from it, and its `page`,
+     * `total` and `total_capped` are `null`. To show another numbered page,
+     * call this method again with its `page` rather than `getNextPage()`.
+     *
+     * `sort` and `dir` other than `timestamp` descending need `page`, or the
+     * API refuses the call with `required` on `page`. A walk from a sorted
+     * page continues by offset and reads every earlier row for each page, so
+     * walk in the default order.
+     *
+     * Needs the `read` scope. Operation `listEvents`.
+     */
+    list(query, options) {
+        return callPage(this.#config, "listEvents", { query, options });
+    }
+    /**
+     * Counts the events `list` holds under the same period, filters and
+     * `as_of`: in all, per day and per category. A day is 24 hours counted
+     * from `from`, so local midnight with its offset as `from` gives local
+     * days. The period is required, also with `import_batch_id`. Without
+     * `import_batch_id`, an event is counted a second or two after the API
+     * stores it, and later while a long request, such as a large import, is
+     * still in progress, so a read straight after an ingest may not count it
+     * yet.
+     *
+     * Needs the `read` scope. Operation `getEventSummary`.
+     */
+    getSummary(query, options) {
+        return call(this.#config, "getEventSummary", { query, options });
+    }
+    /**
+     * Lists the workspace's events in the order the API stored them, newest
+     * first, below an arrival limit, `as_of`, which the response issues.
+     * Await the result for one page; iterate it with `for await` for every
+     * event of every page. `from` and `to` filter by `timestamp`, and each is
+     * optional on its own.
+     *
+     * With `since`, the list holds the events that arrived at or after it, and
+     * `body.count` counts them. To poll, send each response's `as_of` as the
+     * next call's `since` and walk the result: consecutive windows meet
+     * without a gap or an overlap. To learn only how many arrived, pass a
+     * `limit` of 1 and read `body.count`. The SDK does not poll on its own.
+     * `since` may be at most 24 hours back; a feed further behind reloads
+     * without it. An event falls below `as_of` a second or two after the API
+     * stores it, and later while a long request, such as a large import, is
+     * still in progress. A read straight after an ingest may not include it
+     * yet; poll with `since` until it does.
+     *
+     * Needs the `read` scope. Operation `listEventArrivals`.
+     */
+    listArrivals(query, options) {
+        return callPage(this.#config, "listEventArrivals", { query, options });
+    }
+    /**
+     * Lists the events behind a client's totals: the event drill-down, over
+     * the period `from` to `to`.
+     *
+     * Pass `page` or `cursor`, not both; neither means page 1. A `page`
+     * beyond the end returns no rows and the true `total`. Await the result
+     * for one page, whose `body` holds `total` and `period`; iterate it with
+     * `for await` for every event of every page from there.
+     *
+     * Needs the `read` scope. Operation `listClientEvents`.
+     *
+     * @param clientId - the client's id.
+     */
+    listForClient(clientId, query, options) {
+        return callPage(this.#config, "listClientEvents", {
+            path: { id: clientId },
+            query,
+            options,
+        });
+    }
+}

package/dist/resources/health.d.ts

@@ -0,0 +1,14 @@
+import type { RequestOptions } from "../options.js";
+import type { TransportConfig } from "../transport.js";
+import type { Health } from "../types.js";
+/** The `health` operations. */
+export declare class HealthOperations {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Checks liveness. Sends no credential.
+     *
+     * Operation `getHealth`.
+     */
+    get(options?: RequestOptions): Promise<Health>;
+}

package/dist/resources/health.js

@@ -0,0 +1,17 @@
+// The `health` operations.
+import { call } from "../request.js";
+/** The `health` operations. */
+export class HealthOperations {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Checks liveness. Sends no credential.
+     *
+     * Operation `getHealth`.
+     */
+    get(options) {
+        return call(this.#config, "getHealth", { options });
+    }
+}