@allisall/sdk 0.0.0-stage → 0.2.0

package/dist/resources/api-keys.js

@@ -0,0 +1,63 @@
+// The `apiKeys` operations: a workspace's API keys, managed with a
+// session token.
+import { call, callPage } from "../request.js";
+/** The `apiKeys` operations. */
+export class ApiKeys {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Creates an API key, and returns its complete token once. Store the
+     * token at once: no later call returns it, because the API keeps only a
+     * hash.
+     *
+     * Never retried, because a retried create would make a second key. On a
+     * `ConnectionError`, list the keys to learn whether it was created.
+     *
+     * Needs a session token: an API key cannot create a key. An API key is
+     * refused with `403` `session_required`, as an `ApiError`.
+     *
+     * Operation `createApiKey`.
+     */
+    create(body, options) {
+        return call(this.#config, "createApiKey", { body, options });
+    }
+    /**
+     * Lists API keys. Await the result for one page; iterate it with
+     * `for await` for every key of every page.
+     *
+     * Needs a session token. An API key is refused with `403`
+     * `session_required`, as an `ApiError`.
+     *
+     * Operation `listApiKeys`.
+     */
+    list(query, options) {
+        return callPage(this.#config, "listApiKeys", { query, options });
+    }
+    /**
+     * Reads an API key. Its token is never returned.
+     *
+     * Needs a session token. An API key is refused with `403`
+     * `session_required`, as an `ApiError`.
+     *
+     * Operation `getApiKey`.
+     */
+    get(id, options) {
+        return call(this.#config, "getApiKey", { path: { id }, options });
+    }
+    /**
+     * Revokes an API key. The next request bearing the key is refused with
+     * `401`.
+     *
+     * Needs a session token. An API key is refused with `403`
+     * `session_required`, as an `ApiError`. Never retried.
+     *
+     * Operation `revokeApiKey`.
+     *
+     * @param id - the key's `id`, not its token.
+     */
+    revoke(id, options) {
+        return call(this.#config, "revokeApiKey", { path: { id }, options });
+    }
+}

package/dist/resources/calculations.d.ts

@@ -0,0 +1,78 @@
+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";
+/** The `calculations` operations. */
+export declare class Calculations {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * 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
+     * publishing it need a session token.
+     *
+     * Every attempt of the call sends one `Idempotency-Key`, so a retry
+     * cannot create a second calculation.
+     *
+     * Needs the `write` scope. Operation `createCalculation`.
+     *
+     * @param clientId - the client's id.
+     */
+    createForClient(clientId: string, body: CalculationCreate, options?: IdempotentRequestOptions): Promise<Calculation>;
+    /**
+     * Lists a client's calculations. Await the result for one page; iterate
+     * it with `for await` for every calculation of every page.
+     *
+     * Needs the `read` scope. Operation `listClientCalculations`.
+     *
+     * @param clientId - the client's id.
+     */
+    listForClient(clientId: string, query?: ListClientCalculationsQuery, options?: RequestOptions): PagePromise<CalculationSummary, CalculationList>;
+    /**
+     * Reads a calculation.
+     *
+     * Needs the `read` scope. Operation `getCalculation`.
+     */
+    get(id: string, options?: RequestOptions): Promise<Calculation>;
+    /**
+     * Deletes a draft calculation.
+     *
+     * A retry after a lost response can answer `404` for a delete that
+     * succeeded.
+     *
+     * Needs the `write` scope. Operation `deleteCalculation`.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+    /**
+     * Validates a calculation: records the validation checklist, an
+     * attestation that the figures were reviewed, and moves a draft to
+     * `validated`.
+     *
+     * Needs a session token: validation is a human attestation. An API key
+     * is refused with `403` `session_required`, as an `ApiError`. Never
+     * retried.
+     *
+     * Operation `validateCalculation`.
+     */
+    validate(id: string, body: ChecklistInput, options?: RequestOptions): Promise<Calculation>;
+    /**
+     * Publishes a calculation: moves a validated calculation to `published`.
+     * Publication is terminal.
+     *
+     * Needs a session token: publishing is a human trust step. An API key is
+     * refused with `403` `session_required`, as an `ApiError`. Never retried.
+     *
+     * Operation `publishCalculation`.
+     */
+    publish(id: string, options?: RequestOptions): Promise<Calculation>;
+    /**
+     * Reopens a calculation: moves a validated calculation back to `draft`,
+     * clearing its attestation.
+     *
+     * Needs a session token: it undoes a human trust step. An API key is
+     * refused with `403` `session_required`, as an `ApiError`. Never retried.
+     *
+     * Operation `reopenCalculation`.
+     */
+    reopen(id: string, options?: RequestOptions): Promise<Calculation>;
+}

package/dist/resources/calculations.js

@@ -0,0 +1,111 @@
+// The `calculations` operations: a client's frozen ROI for a period, and
+// the human steps that validate, publish and reopen it.
+import { call, callPage } from "../request.js";
+/** The `calculations` operations. */
+export class Calculations {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * 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
+     * publishing it need a session token.
+     *
+     * Every attempt of the call sends one `Idempotency-Key`, so a retry
+     * cannot create a second calculation.
+     *
+     * Needs the `write` scope. Operation `createCalculation`.
+     *
+     * @param clientId - the client's id.
+     */
+    createForClient(clientId, body, options) {
+        return call(this.#config, "createCalculation", {
+            path: { id: clientId },
+            body,
+            options,
+        });
+    }
+    /**
+     * Lists a client's calculations. Await the result for one page; iterate
+     * it with `for await` for every calculation of every page.
+     *
+     * Needs the `read` scope. Operation `listClientCalculations`.
+     *
+     * @param clientId - the client's id.
+     */
+    listForClient(clientId, query, options) {
+        return callPage(this.#config, "listClientCalculations", {
+            path: { id: clientId },
+            query,
+            options,
+        });
+    }
+    /**
+     * Reads a calculation.
+     *
+     * Needs the `read` scope. Operation `getCalculation`.
+     */
+    get(id, options) {
+        return call(this.#config, "getCalculation", { path: { id }, options });
+    }
+    /**
+     * Deletes a draft calculation.
+     *
+     * A retry after a lost response can answer `404` for a delete that
+     * succeeded.
+     *
+     * Needs the `write` scope. Operation `deleteCalculation`.
+     */
+    delete(id, options) {
+        return call(this.#config, "deleteCalculation", { path: { id }, options });
+    }
+    /**
+     * Validates a calculation: records the validation checklist, an
+     * attestation that the figures were reviewed, and moves a draft to
+     * `validated`.
+     *
+     * Needs a session token: validation is a human attestation. An API key
+     * is refused with `403` `session_required`, as an `ApiError`. Never
+     * retried.
+     *
+     * Operation `validateCalculation`.
+     */
+    validate(id, body, options) {
+        return call(this.#config, "validateCalculation", {
+            path: { id },
+            body,
+            options,
+        });
+    }
+    /**
+     * Publishes a calculation: moves a validated calculation to `published`.
+     * Publication is terminal.
+     *
+     * Needs a session token: publishing is a human trust step. An API key is
+     * refused with `403` `session_required`, as an `ApiError`. Never retried.
+     *
+     * Operation `publishCalculation`.
+     */
+    publish(id, options) {
+        return call(this.#config, "publishCalculation", {
+            path: { id },
+            options,
+        });
+    }
+    /**
+     * Reopens a calculation: moves a validated calculation back to `draft`,
+     * clearing its attestation.
+     *
+     * Needs a session token: it undoes a human trust step. An API key is
+     * refused with `403` `session_required`, as an `ApiError`. Never retried.
+     *
+     * Operation `reopenCalculation`.
+     */
+    reopen(id, options) {
+        return call(this.#config, "reopenCalculation", {
+            path: { id },
+            options,
+        });
+    }
+}

package/dist/resources/clients.d.ts

@@ -0,0 +1,65 @@
+import type { IdempotentRequestOptions, RequestOptions } from "../options.js";
+import type { PagePromise } from "../pagination.js";
+import type { TransportConfig } from "../transport.js";
+import type { Client, ClientAgents, ClientAgentsSet, ClientCreate, ClientDetail, ClientList, ClientPatch, ListClientsQuery } from "../types.js";
+/** The `clients` operations. */
+export declare class Clients {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Lists clients. Await the result for one page; iterate it with
+     * `for await` for every client of every page.
+     *
+     * Needs the `read` scope. Operation `listClients`.
+     */
+    list(query?: ListClientsQuery, options?: RequestOptions): PagePromise<Client, ClientList>;
+    /**
+     * Creates a client.
+     *
+     * 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: ClientCreate, options?: IdempotentRequestOptions): Promise<Client>;
+    /**
+     * Reads a client.
+     *
+     * Needs the `read` scope. Operation `getClient`.
+     */
+    get(id: string, options?: RequestOptions): Promise<ClientDetail>;
+    /**
+     * Updates a client with a merge patch: a member left out keeps its
+     * value, `null` clears it, and any other value sets it.
+     *
+     * Never retried.
+     *
+     * Needs the `write` scope. Operation `updateClient`.
+     */
+    update(id: string, patch: ClientPatch, options?: RequestOptions): Promise<Client>;
+    /**
+     * 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: string, options?: RequestOptions): Promise<void>;
+    /**
+     * 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: string, body: ClientAgentsSet, options?: RequestOptions): Promise<ClientAgents>;
+}

package/dist/resources/clients.js

@@ -0,0 +1,85 @@
+// 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.
+     *
+     * Needs the `read` scope. Operation `listClients`.
+     */
+    list(query, options) {
+        return callPage(this.#config, "listClients", { query, options });
+    }
+    /**
+     * Creates a client.
+     *
+     * 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.
+     *
+     * 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,69 @@
+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.
+     *
+     * 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,89 @@
+// 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.
+     *
+     * 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,24 @@
+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.
+     *
+     * Needs the `read` scope. Operation `listRenewals`.
+     */
+    listRenewals(query?: ListRenewalsQuery, options?: RequestOptions): PagePromise<Renewal, RenewalList>;
+}

package/dist/resources/dashboard.js

@@ -0,0 +1,28 @@
+// 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.
+     *
+     * 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,47 @@
+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";
+/** 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 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>;
+}