@allisall/sdk 0.1.0 → 0.4.0

package/dist/resources/agents.d.ts

@@ -0,0 +1,58 @@
+import type { IdempotentRequestOptions, RequestOptions } from "../options.js";
+import type { PagePromise } from "../pagination.js";
+import type { TransportConfig } from "../transport.js";
+import type { Agent, AgentCreate, AgentDetail, AgentList, AgentListItem, AgentPatch, GetAgentQuery, ListAgentsQuery } from "../types.js";
+/** The `agents` operations. */
+export declare class Agents {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * 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>;
+    /**
+     * Creates an agent.
+     *
+     * Every attempt of the call sends one `Idempotency-Key`, so a retry
+     * cannot create a second agent.
+     *
+     * Needs the `write` scope. Operation `createAgent`.
+     */
+    create(body: AgentCreate, options?: IdempotentRequestOptions): Promise<Agent>;
+    /**
+     * Reads an agent, with its statistics. `from` and `to` bound the
+     * statistics only; absent bounds mean all time.
+     *
+     * Needs the `read` scope. Operation `getAgent`.
+     */
+    get(id: string, query?: GetAgentQuery, options?: RequestOptions): Promise<AgentDetail>;
+    /**
+     * Updates an agent 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 `updateAgent`.
+     */
+    update(id: string, patch: AgentPatch, options?: RequestOptions): Promise<Agent>;
+    /**
+     * Deletes an agent. Refused while events reference the agent; set its
+     * status to `retired` instead.
+     *
+     * A retry after a lost response can answer `404` for a delete that
+     * succeeded.
+     *
+     * Needs the `write` scope. Operation `deleteAgent`.
+     */
+    delete(id: string, options?: RequestOptions): Promise<void>;
+}

package/dist/resources/agents.js

@@ -0,0 +1,72 @@
+// The `agents` operations.
+import { call, callPage } from "../request.js";
+/** The `agents` operations. */
+export class Agents {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * 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) {
+        return callPage(this.#config, "listAgents", { query, options });
+    }
+    /**
+     * Creates an agent.
+     *
+     * Every attempt of the call sends one `Idempotency-Key`, so a retry
+     * cannot create a second agent.
+     *
+     * Needs the `write` scope. Operation `createAgent`.
+     */
+    create(body, options) {
+        return call(this.#config, "createAgent", { body, options });
+    }
+    /**
+     * Reads an agent, with its statistics. `from` and `to` bound the
+     * statistics only; absent bounds mean all time.
+     *
+     * Needs the `read` scope. Operation `getAgent`.
+     */
+    get(id, query, options) {
+        return call(this.#config, "getAgent", { path: { id }, query, options });
+    }
+    /**
+     * Updates an agent 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 `updateAgent`.
+     */
+    update(id, patch, options) {
+        return call(this.#config, "updateAgent", {
+            path: { id },
+            body: patch,
+            options,
+        });
+    }
+    /**
+     * Deletes an agent. Refused while events reference the agent; set its
+     * status to `retired` instead.
+     *
+     * A retry after a lost response can answer `404` for a delete that
+     * succeeded.
+     *
+     * Needs the `write` scope. Operation `deleteAgent`.
+     */
+    delete(id, options) {
+        return call(this.#config, "deleteAgent", { path: { id }, options });
+    }
+}

package/dist/resources/analytics.d.ts

@@ -0,0 +1,42 @@
+import type { RequestOptions } from "../options.js";
+import type { TransportConfig } from "../transport.js";
+import type { Anomalies, ClientCost, ClientValue, GetClientAnomaliesQuery, GetClientCostQuery, GetClientRoiQuery, GetClientValueQuery, RoiResult } from "../types.js";
+/** The `analytics` operations. */
+export declare class Analytics {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Computes a client's value.
+     *
+     * Needs the `read` scope. Operation `getClientValue`.
+     *
+     * @param clientId - the client's id.
+     */
+    getValueForClient(clientId: string, query?: GetClientValueQuery, options?: RequestOptions): Promise<ClientValue>;
+    /**
+     * Computes a client's cost over a period. Both bounds are required:
+     * standing charges are prorated day by day, so an open `from` would
+     * prorate each charge from its own start date, however long ago.
+     *
+     * Needs the `read` scope. Operation `getClientCost`.
+     *
+     * @param clientId - the client's id.
+     */
+    getCostForClient(clientId: string, query: GetClientCostQuery, options?: RequestOptions): Promise<ClientCost>;
+    /**
+     * Computes a client's ROI over a period.
+     *
+     * Needs the `read` scope. Operation `getClientRoi`.
+     *
+     * @param clientId - the client's id.
+     */
+    getRoiForClient(clientId: string, query: GetClientRoiQuery, options?: RequestOptions): Promise<RoiResult>;
+    /**
+     * Flags anomalies in a client's period.
+     *
+     * Needs the `read` scope. Operation `getClientAnomalies`.
+     *
+     * @param clientId - the client's id.
+     */
+    getAnomaliesForClient(clientId: string, query: GetClientAnomaliesQuery, options?: RequestOptions): Promise<Anomalies>;
+}

package/dist/resources/analytics.js

@@ -0,0 +1,68 @@
+// The `analytics` operations: a client's value, cost, ROI and anomalies
+// over a period.
+import { call } from "../request.js";
+/** The `analytics` operations. */
+export class Analytics {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Computes a client's value.
+     *
+     * Needs the `read` scope. Operation `getClientValue`.
+     *
+     * @param clientId - the client's id.
+     */
+    getValueForClient(clientId, query, options) {
+        return call(this.#config, "getClientValue", {
+            path: { id: clientId },
+            query,
+            options,
+        });
+    }
+    /**
+     * Computes a client's cost over a period. Both bounds are required:
+     * standing charges are prorated day by day, so an open `from` would
+     * prorate each charge from its own start date, however long ago.
+     *
+     * Needs the `read` scope. Operation `getClientCost`.
+     *
+     * @param clientId - the client's id.
+     */
+    getCostForClient(clientId, query, options) {
+        return call(this.#config, "getClientCost", {
+            path: { id: clientId },
+            query,
+            options,
+        });
+    }
+    /**
+     * Computes a client's ROI over a period.
+     *
+     * Needs the `read` scope. Operation `getClientRoi`.
+     *
+     * @param clientId - the client's id.
+     */
+    getRoiForClient(clientId, query, options) {
+        return call(this.#config, "getClientRoi", {
+            path: { id: clientId },
+            query,
+            options,
+        });
+    }
+    /**
+     * Flags anomalies in a client's period.
+     *
+     * Needs the `read` scope. Operation `getClientAnomalies`.
+     *
+     * @param clientId - the client's id.
+     */
+    getAnomaliesForClient(clientId, query, options) {
+        return call(this.#config, "getClientAnomalies", {
+            path: { id: clientId },
+            query,
+            options,
+        });
+    }
+}

package/dist/resources/api-keys.d.ts

@@ -0,0 +1,54 @@
+import type { RequestOptions } from "../options.js";
+import type { PagePromise } from "../pagination.js";
+import type { TransportConfig } from "../transport.js";
+import type { ApiKey, ApiKeyCreate, ApiKeyList, ApiKeyWithToken, ListApiKeysQuery } from "../types.js";
+/** The `apiKeys` operations. */
+export declare class ApiKeys {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * 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: ApiKeyCreate, options?: RequestOptions): Promise<ApiKeyWithToken>;
+    /**
+     * 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?: ListApiKeysQuery, options?: RequestOptions): PagePromise<ApiKey, ApiKeyList>;
+    /**
+     * 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: string, options?: RequestOptions): Promise<ApiKey>;
+    /**
+     * 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: string, options?: RequestOptions): Promise<ApiKey>;
+}

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,98 @@
+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, 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
+     * 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,133 @@
+// 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;
+    }
+    /**
+     * 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
+     * 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,93 @@
+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.
+     *
+     * 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.
+     *
+     * 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.
+     *
+     * 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: 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>;
+}