@clocknext/sdk 0.14.0 → 0.15.0

package/src/resources/composites.ts

@@ -1,47 +0,0 @@
-import { activeQuery, filterByActive } from "../filters.js";
-import type { Transport } from "../http.js";
-import type { Composite, CreateCompositeInput } from "../types.js";
-
-/**
- * The `composites` resource — manage the org's composite *catalogue*: the
- * bundles of credits / outcomes / units that are grouped under one tag and
- * sold on a plan as a single thing. `/api/v1/composites`.
- *
- * Two things live elsewhere, deliberately:
- *   • Tagging a signal into a composite occurrence is `composite: { ref, value }`
- *     on the signal itself (see `signals.credit()` / `.outcome()` / `.unit()`).
- *   • Closing an occurrence — the moment it is billed — is
- *     `signals.completeComposite()`.
- *
- * This resource only defines what composites EXIST. Creating one prices it but
- * charges nobody: an invoice is built from plan components, never from a
- * catalogue entry, so a composite starts costing money only once a plan sells
- * it (`quantity × price`, frozen into the purchase at buy time).
- */
-export class Composites {
-  constructor(private readonly transport: Transport) {}
-
-  /** List composites. Pass `{ active: true }` for only the ones a signal can
-   *  still be tagged with — the default list INCLUDES archived ones, which
-   *  keep every row they already own.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params: { active?: boolean } = {}): Promise<Composite[]> {
-    const res = await this.transport.request<{ composites: Composite[] }>({
-      method: "GET",
-      path: "/api/v1/composites",
-      query: { active: activeQuery(params.active) },
-    });
-    return filterByActive(res.composites, params.active);
-  }
-
-  /** Create a composite. `POST /api/v1/composites`. */
-  async create(input: CreateCompositeInput): Promise<Composite> {
-    const res = await this.transport.request<{ composite: Composite }>({
-      method: "POST",
-      path: "/api/v1/composites",
-      body: input,
-    });
-    return res.composite;
-  }
-}

package/src/resources/credits.ts

@@ -1,76 +0,0 @@
-import { activeQuery, filterByActive } from "../filters.js";
-import type { Transport } from "../http.js";
-import type {
-  CreateCreditInput,
-  Credit,
-  CreditDetail,
-  UpdateCreditInput,
-} from "../types.js";
-
-/**
- * The `credits` resource — manage the org's credit *types* (the catalog). A
- * credit's stable `agentKey` is what you pass to `signals.credit()` when
- * recording usage against it. `/api/v1/credits`.
- */
-export class Credits {
-  constructor(private readonly transport: Transport) {}
-
-  /** List credit types. Pass `{ active: true }` to only return active ones.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params: { active?: boolean } = {}): Promise<Credit[]> {
-    const res = await this.transport.request<{ credits: Credit[] }>({
-      method: "GET",
-      path: "/api/v1/credits",
-      query: { active: activeQuery(params.active) },
-    });
-    return filterByActive(res.credits, params.active);
-  }
-
-  /** Create a credit type; returns the created credit. `POST /api/v1/credits`. */
-  async create(input: CreateCreditInput): Promise<Credit> {
-    const res = await this.transport.request<{ credit: Credit }>({
-      method: "POST",
-      path: "/api/v1/credits",
-      body: input,
-    });
-    return res.credit;
-  }
-
-  /** Fetch one credit type with usage stats. `GET /api/v1/credits/:id`. */
-  async get(id: string): Promise<CreditDetail> {
-    const res = await this.transport.request<{ credit: CreditDetail }>({
-      method: "GET",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`,
-    });
-    return res.credit;
-  }
-
-  /** Update a credit type's definition; returns the updated credit. `PATCH /api/v1/credits/:id`. */
-  async update(id: string, input: UpdateCreditInput): Promise<Credit> {
-    const res = await this.transport.request<{ credit: Credit }>({
-      method: "PATCH",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`,
-      body: input,
-    });
-    return res.credit;
-  }
-
-  /** Activate or deactivate a credit type. */
-  async setActive(id: string, isActive: boolean): Promise<Credit> {
-    const res = await this.transport.request<{ credit: Credit }>({
-      method: "PATCH",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`,
-      body: { isActive },
-    });
-    return res.credit;
-  }
-
-  /** Delete a credit type. Refused while a customer is linked to it. */
-  async delete(id: string): Promise<void> {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`,
-    });
-  }
-}

package/src/resources/outcomes.ts

@@ -1,82 +0,0 @@
-import { activeQuery, filterByActive } from "../filters.js";
-import type { Transport } from "../http.js";
-import type {
-  CreateOutcomeInput,
-  Outcome,
-  OutcomeDetail,
-  UpdateOutcomeInput,
-} from "../types.js";
-
-/**
- * The `outcomes` resource — manage the org's outcome *types* (the catalog). An
- * outcome is a multi-step workflow. `/api/v1/outcomes`.
- *
- * Two distinct kinds of agent key, in separate namespaces, each unique per
- * organisation — do not conflate them:
- * - the OUTCOME's own `agentKey`, REQUIRED on `create()` and `update()`, which
- *   names the outcome itself in the catalogue;
- * - each STEP's `agentKey`, which is what you pass to `signals.outcome()` to
- *   report usage and to the outcome-adjust API.
- */
-export class Outcomes {
-  constructor(private readonly transport: Transport) {}
-
-  /** List outcome types. Pass `{ active: true }` to only return active ones.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params: { active?: boolean } = {}): Promise<Outcome[]> {
-    const res = await this.transport.request<{ outcomes: Outcome[] }>({
-      method: "GET",
-      path: "/api/v1/outcomes",
-      query: { active: activeQuery(params.active) },
-    });
-    return filterByActive(res.outcomes, params.active);
-  }
-
-  /** Create an outcome type with its steps. `POST /api/v1/outcomes`. */
-  async create(input: CreateOutcomeInput): Promise<Outcome> {
-    const res = await this.transport.request<{ outcome: Outcome }>({
-      method: "POST",
-      path: "/api/v1/outcomes",
-      body: input,
-    });
-    return res.outcome;
-  }
-
-  /** Fetch one outcome type with steps + stats. `GET /api/v1/outcomes/:id`. */
-  async get(id: string): Promise<OutcomeDetail> {
-    const res = await this.transport.request<{ outcome: OutcomeDetail }>({
-      method: "GET",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
-    });
-    return res.outcome;
-  }
-
-  /** Update an outcome type's definition. `PATCH /api/v1/outcomes/:id`. */
-  async update(id: string, input: UpdateOutcomeInput): Promise<Outcome> {
-    const res = await this.transport.request<{ outcome: Outcome }>({
-      method: "PATCH",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
-      body: input,
-    });
-    return res.outcome;
-  }
-
-  /** Activate or deactivate an outcome type; returns the updated outcome. */
-  async setActive(id: string, isActive: boolean): Promise<Outcome> {
-    const res = await this.transport.request<{ outcome: Outcome }>({
-      method: "PATCH",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
-      body: { isActive },
-    });
-    return res.outcome;
-  }
-
-  /** Delete an outcome type. */
-  async delete(id: string): Promise<void> {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
-    });
-  }
-}

package/src/resources/units.ts

@@ -1,76 +0,0 @@
-import { activeQuery, filterByActive } from "../filters.js";
-import type { Transport } from "../http.js";
-import type {
-  CreateUnitInput,
-  Unit,
-  UnitDetail,
-  UpdateUnitInput,
-} from "../types.js";
-
-/**
- * The `units` resource — manage the org's unit *types* (the catalog): named,
- * quantity-priced meters (FLAT / SLAB / VOLUME). Record consumption against a
- * unit with `signals.unit()`. `/api/v1/units-catalog`.
- */
-export class Units {
-  constructor(private readonly transport: Transport) {}
-
-  /** List unit types. Pass `{ active: true }` to only return active ones.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params: { active?: boolean } = {}): Promise<Unit[]> {
-    const res = await this.transport.request<{ units: Unit[] }>({
-      method: "GET",
-      path: "/api/v1/units-catalog",
-      query: { active: activeQuery(params.active) },
-    });
-    return filterByActive(res.units, params.active);
-  }
-
-  /** Create a unit type. `POST /api/v1/units-catalog`. */
-  async create(input: CreateUnitInput): Promise<Unit> {
-    const res = await this.transport.request<{ unit: Unit }>({
-      method: "POST",
-      path: "/api/v1/units-catalog",
-      body: input,
-    });
-    return res.unit;
-  }
-
-  /** Fetch one unit type with stats. `GET /api/v1/units-catalog/:id`. */
-  async get(id: string): Promise<UnitDetail> {
-    const res = await this.transport.request<{ unit: UnitDetail }>({
-      method: "GET",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`,
-    });
-    return res.unit;
-  }
-
-  /** Update a unit type's definition. `PATCH /api/v1/units-catalog/:id`. */
-  async update(id: string, input: UpdateUnitInput): Promise<Unit> {
-    const res = await this.transport.request<{ unit: Unit }>({
-      method: "PATCH",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`,
-      body: input,
-    });
-    return res.unit;
-  }
-
-  /** Activate or deactivate a unit type. */
-  async setActive(id: string, isActive: boolean): Promise<Unit> {
-    const res = await this.transport.request<{ unit: Unit }>({
-      method: "PATCH",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`,
-      body: { isActive },
-    });
-    return res.unit;
-  }
-
-  /** Delete a unit type. */
-  async delete(id: string): Promise<void> {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`,
-    });
-  }
-}

package/src/resources/webhooks.ts

@@ -1,37 +0,0 @@
-import type { Transport } from "../http.js";
-import type { ThresholdKind, UpsertWebhookInput, Webhook } from "../types.js";
-
-/**
- * The `webhooks` resource — threshold alerts. At most one webhook per kind
- * (CREDIT / OUTCOME / WALLET); posting a kind again upserts it. `/api/v1/webhooks`.
- */
-export class Webhooks {
-  constructor(private readonly transport: Transport) {}
-
-  /** List configured webhooks. `GET /api/v1/webhooks`. */
-  async list(): Promise<Webhook[]> {
-    const res = await this.transport.request<{ webhooks: Webhook[] }>({
-      method: "GET",
-      path: "/api/v1/webhooks",
-    });
-    return res.webhooks;
-  }
-
-  /** Create or replace the webhook for a kind. `POST /api/v1/webhooks`. */
-  async upsert(input: UpsertWebhookInput): Promise<Webhook> {
-    const res = await this.transport.request<{ webhook: Webhook }>({
-      method: "POST",
-      path: "/api/v1/webhooks",
-      body: input,
-    });
-    return res.webhook;
-  }
-
-  /** Delete the webhook for a kind (idempotent). `DELETE /api/v1/webhooks/:kind`. */
-  async delete(kind: ThresholdKind): Promise<void> {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/webhooks/${encodeURIComponent(kind)}`,
-    });
-  }
-}

package/src/resources/workspace.ts

@@ -1,33 +0,0 @@
-import { activeQuery, filterByActive } from "../filters.js";
-import type { Transport } from "../http.js";
-import type { Model, WorkspaceIdentity } from "../types.js";
-
-/**
- * The `workspace` resource — read-only introspection of the org behind the API
- * key. Grounds an integration (which workspace, and is it `sandbox` or `live`?)
- * and lists the models it may meter against. `/api/v1/me`, `/api/v1/models`.
- */
-export class Workspace {
-  constructor(private readonly transport: Transport) {}
-
-  /** Identify the org + key behind the request, incl. `sandbox` | `live`. */
-  me(): Promise<WorkspaceIdentity> {
-    return this.transport.request<WorkspaceIdentity>({
-      method: "GET",
-      path: "/api/v1/me",
-    });
-  }
-
-  /** The org's enabled models with live prices. `{ active: true }` returns only
-   *  the models that can be metered right now.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async models(params: { active?: boolean } = {}): Promise<Model[]> {
-    const res = await this.transport.request<{ models: Model[] }>({
-      method: "GET",
-      path: "/api/v1/models",
-      query: { active: activeQuery(params.active) },
-    });
-    return filterByActive(res.models, params.active);
-  }
-}