@allisall/sdk 0.2.0 → 0.4.0

package/dist/request.d.ts

@@ -78,6 +78,15 @@ export declare function requestPage<K extends OperationId>(config: TransportConf
  * options paging sets for that page. Every other member is carried forward.
  */
 export declare function pageArgs(args: CallArgs, query: object | undefined, options: RequestOptions): CallArgs;
+/**
+ * The query member a walk pins to its first page's answer, by operation:
+ * when the caller's query leaves the member out, every later page sends the
+ * value the first page's body echoed. On the renewals list it is `today`,
+ * so a walk that crosses UTC midnight reads every page under one date.
+ */
+export declare const PINNED_ECHO: {
+    readonly [K in OperationId]?: string;
+};
 /** An operation's path parameters, from the generated types. */
 type PathOf<K extends OperationId> = NonNullable<operations[K]["parameters"]["path"]>;
 /**

package/dist/request.js

@@ -69,6 +69,21 @@ function buildURL(config, operation, path, query) {
             // An absent member is left out; the SDK writes no parameter of its own.
             if (value === undefined)
                 continue;
+            if (operation.repeatable.includes(name)) {
+                // One parameter per item, in order. Only an array is accepted, so a
+                // lone string is refused too; an empty array has no faithful form,
+                // because leaving the parameter out means every value.
+                if (!Array.isArray(value)) {
+                    throw new TypeError(`allisall: the query parameter ${name} takes an array of values`);
+                }
+                if (value.length === 0) {
+                    throw new TypeError(`allisall: the query parameter ${name} is an empty array; leave it out to match every value`);
+                }
+                for (const item of value) {
+                    url.searchParams.append(name, queryText(name, item));
+                }
+                continue;
+            }
             url.searchParams.append(name, queryText(name, value));
         }
     }
@@ -303,8 +318,17 @@ export function requestPage(config, id, args = {}) {
         const body = await requestAccepting(config, id, pageArgs(args, query, options), breaksNoCycle(position + 1));
         // A list operation's reader checked the envelope.
         const list = body;
+        const pinnedName = PINNED_ECHO[id];
+        const pinnedValue = pinnedName === undefined ? undefined : Reflect.get(list, pinnedName);
         const next = list.has_more && typeof list.next_cursor === "string"
-            ? nextQuery(query, list.next_cursor)
+            ? nextQuery(query, list.next_cursor, 
+            // An empty or non-string echo is not pinned: the API refuses an
+            // empty parameter.
+            pinnedName !== undefined &&
+                typeof pinnedValue === "string" &&
+                pinnedValue !== ""
+                ? { name: pinnedName, value: pinnedValue }
+                : undefined)
             : undefined;
         return new Page(list, next === undefined
             ? undefined
@@ -343,13 +367,29 @@ function overlay(call, override) {
     }
     return merged;
 }
-/** The query of the next page: the same members, `page` dropped, `cursor` set. */
-function nextQuery(query, cursor) {
+/**
+ * The query member a walk pins to its first page's answer, by operation:
+ * when the caller's query leaves the member out, every later page sends the
+ * value the first page's body echoed. On the renewals list it is `today`,
+ * so a walk that crosses UTC midnight reads every page under one date.
+ */
+export const PINNED_ECHO = {
+    listRenewals: "today",
+};
+/**
+ * The query of the next page: the same members, `page` dropped, `cursor`
+ * set, and the pinned member, when the caller left it out, set to the value
+ * the first page echoed.
+ */
+function nextQuery(query, cursor, pinned) {
     const next = {};
     for (const [name, value] of Object.entries(query ?? {})) {
         if (name !== "page")
             next[name] = value;
     }
+    if (pinned !== undefined && next[pinned.name] === undefined) {
+        next[pinned.name] = pinned.value;
+    }
     next.cursor = cursor;
     return next;
 }

package/dist/resources/agents.d.ts

@@ -10,6 +10,13 @@ export declare class Agents {
      * Lists agents. Await the result for one page; iterate it with
      * `for await` for every agent 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 `listAgents`.
      */
     list(query?: ListAgentsQuery, options?: RequestOptions): PagePromise<AgentListItem, AgentList>;

package/dist/resources/agents.js

@@ -10,6 +10,13 @@ export class Agents {
      * Lists agents. Await the result for one page; iterate it with
      * `for await` for every agent 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 `listAgents`.
      */
     list(query, options) {

package/dist/resources/calculations.d.ts

@@ -1,11 +1,31 @@
 import type { IdempotentRequestOptions, RequestOptions } from "../options.js";
 import type { PagePromise } from "../pagination.js";
 import type { TransportConfig } from "../transport.js";
-import type { Calculation, CalculationCreate, CalculationList, CalculationSummary, ChecklistInput, ListClientCalculationsQuery } from "../types.js";
+import type { Calculation, CalculationCreate, CalculationList, CalculationSummary, ChecklistInput, ListCalculationsQuery, ListClientCalculationsQuery, WorkspaceCalculationList } from "../types.js";
 /** The `calculations` operations. */
 export declare class Calculations {
     #private;
     constructor(config: TransportConfig);
+    /**
+     * Lists the workspace's calculations across clients, without snapshots.
+     * Await the result for one page; iterate it with `for await` for every
+     * calculation of every page. `month` takes `YYYY-MM` and matches only a
+     * period that is exactly that calendar month in UTC.
+     *
+     * Calculations come latest period first, then newest first.
+     * `is_current` is decided among each client's own calculations for the
+     * period, before any filter or page applies.
+     *
+     * 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 `listCalculations`.
+     */
+    list(query?: ListCalculationsQuery, options?: RequestOptions): PagePromise<CalculationSummary, WorkspaceCalculationList>;
     /**
      * Freezes a client's ROI for an ended period as a draft calculation. An
      * API key with the `write` scope may create a draft; validating and

package/dist/resources/calculations.js

@@ -7,6 +7,28 @@ export class Calculations {
     constructor(config) {
         this.#config = config;
     }
+    /**
+     * Lists the workspace's calculations across clients, without snapshots.
+     * Await the result for one page; iterate it with `for await` for every
+     * calculation of every page. `month` takes `YYYY-MM` and matches only a
+     * period that is exactly that calendar month in UTC.
+     *
+     * Calculations come latest period first, then newest first.
+     * `is_current` is decided among each client's own calculations for the
+     * period, before any filter or page applies.
+     *
+     * 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 `listCalculations`.
+     */
+    list(query, options) {
+        return callPage(this.#config, "listCalculations", { query, options });
+    }
     /**
      * Freezes a client's ROI for an ended period as a draft calculation. An
      * API key with the `write` scope may create a draft; validating and

package/dist/resources/clients.d.ts

@@ -10,12 +10,28 @@ export declare class Clients {
      * 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?: ListClientsQuery, options?: RequestOptions): PagePromise<Client, ClientList>;
     /**
      * 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.
      *
@@ -32,6 +48,18 @@ export declare class Clients {
      * 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`.

package/dist/resources/clients.js

@@ -10,6 +10,13 @@ export class Clients {
      * 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) {
@@ -18,6 +25,15 @@ export class Clients {
     /**
      * 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.
      *
@@ -38,6 +54,18 @@ export class Clients {
      * 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`.

package/dist/resources/cost.d.ts

@@ -11,6 +11,13 @@ export declare class Cost {
      * 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>;

package/dist/resources/cost.js

@@ -10,6 +10,13 @@ export class Cost {
      * 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) {

package/dist/resources/dashboard.d.ts

@@ -18,6 +18,14 @@ export declare class DashboardOperations {
      * 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

@@ -20,6 +20,14 @@ export class DashboardOperations {
      * 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) {

package/dist/resources/events.d.ts

@@ -1,7 +1,7 @@
 import type { RequestOptions } from "../options.js";
 import type { PagePromise } from "../pagination.js";
 import { type TransportConfig } from "../transport.js";
-import type { AttributedEvent, ClientEventList, EventInput, IngestSummary, ListClientEventsQuery } from "../types.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;
@@ -30,6 +30,75 @@ export declare class Events {
      * 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`.

package/dist/resources/events.js

@@ -1,7 +1,8 @@
-// The `events` operations: ingest, and the event drill-down.
+// 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 { callPage, policyOf } from "../request.js";
+import { call, callPage, policyOf } from "../request.js";
 import { post } from "../transport.js";
 /** The `events` operations. */
 export class Events {
@@ -46,6 +47,81 @@ export class Events {
         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`.

package/dist/resources/imports.d.ts

@@ -1,11 +1,34 @@
 import type { ImportUpload } from "../multipart.js";
 import type { IdempotentRequestOptions, RequestOptions } from "../options.js";
+import type { PagePromise } from "../pagination.js";
 import type { TransportConfig } from "../transport.js";
-import type { ImportPreview, ImportResult } from "../types.js";
+import type { Import, ImportList, ImportPreview, ImportResult, ImportSummary, ListImportsQuery } from "../types.js";
 /** The `imports` operations. */
 export declare class Imports {
     #private;
     constructor(config: TransportConfig);
+    /**
+     * Lists the workspace's imports, newest first, each with its counts.
+     * Await the result for one page; iterate it with `for await` for every
+     * import 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 `listImports`.
+     */
+    list(query?: ListImportsQuery, options?: RequestOptions): PagePromise<ImportSummary, ImportList>;
+    /**
+     * Reads an import, with the mapping it ran with. Pass that mapping to
+     * `toImportMapping` to send it as the next import's mapping.
+     *
+     * Needs the `read` scope. Operation `getImport`.
+     */
+    get(id: string, options?: RequestOptions): Promise<Import>;
     /**
      * Previews a CSV import: parses, maps and validates the file exactly as
      * `commit` would, and writes nothing.

package/dist/resources/imports.js

@@ -1,11 +1,37 @@
 // The `imports` operations: a CSV file of events, previewed or committed.
-import { call } from "../request.js";
+import { call, callPage } from "../request.js";
 /** The `imports` operations. */
 export class Imports {
     #config;
     constructor(config) {
         this.#config = config;
     }
+    /**
+     * Lists the workspace's imports, newest first, each with its counts.
+     * Await the result for one page; iterate it with `for await` for every
+     * import 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 `listImports`.
+     */
+    list(query, options) {
+        return callPage(this.#config, "listImports", { query, options });
+    }
+    /**
+     * Reads an import, with the mapping it ran with. Pass that mapping to
+     * `toImportMapping` to send it as the next import's mapping.
+     *
+     * Needs the `read` scope. Operation `getImport`.
+     */
+    get(id, options) {
+        return call(this.#config, "getImport", { path: { id }, options });
+    }
     /**
      * Previews a CSV import: parses, maps and validates the file exactly as
      * `commit` would, and writes nothing.

package/dist/resources/onboarding.d.ts

@@ -0,0 +1,29 @@
+import type { RequestOptions } from "../options.js";
+import type { TransportConfig } from "../transport.js";
+import type { Onboarding, OnboardingSkippedStepsSet } from "../types.js";
+/** The `onboarding` operations. */
+export declare class OnboardingOperations {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Reads the guided setup's progress: the five steps in their fixed
+     * order, each with whether the workspace's data completes it and when it
+     * was skipped, and `current_step`, the first step neither completed nor
+     * skipped. This is the read for the guided setup's progress.
+     *
+     * Needs the `read` scope. Operation `getOnboarding`.
+     */
+    get(options?: RequestOptions): Promise<Onboarding>;
+    /**
+     * Replaces the set of skipped steps, and resolves with the whole
+     * progress. `steps` replaces the whole set: a step left out is no longer
+     * skipped, and `[]` clears every skip. A step already skipped keeps its
+     * `skipped_at`.
+     *
+     * Retried on a failure worth retrying, because a repeat leaves the same
+     * set.
+     *
+     * Needs the `write` scope. Operation `setOnboardingSkippedSteps`.
+     */
+    setSkippedSteps(body: OnboardingSkippedStepsSet, options?: RequestOptions): Promise<Onboarding>;
+}