@elmohq/sdk 0.0.0-claim → 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Blue Whale Software, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,326 @@
-# @elmohq/sdk
+# Elmo TypeScript SDK
 
-This version holds nothing. It claims the name, so https://github.com/elmohq/elmo-sdk-typescript can publish every version after it.
+[![npm](https://img.shields.io/npm/v/@elmohq/sdk)](https://www.npmjs.com/package/@elmohq/sdk) [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE.md)
+
+Read and manage the brands, prompts, competitors, and AI-visibility analytics of this deployment.
+
+This package calls the Elmo API from TypeScript and JavaScript. It includes types for every request and reply.
+
+[Issues](https://github.com/elmohq/elmo-sdk-typescript/issues)
+
+## Installation
+
+The SDK is published on [npm](https://www.npmjs.com/package/@elmohq/sdk). Install it with the package manager you use.
+
+```sh
+npm install @elmohq/sdk
+```
+
+<details>
+<summary>Other package managers</summary>
+
+```sh
+pnpm add @elmohq/sdk
+```
+
+```sh
+yarn add @elmohq/sdk
+```
+
+```sh
+bun add @elmohq/sdk
+```
+
+```sh
+deno add npm:@elmohq/sdk
+```
+
+```sh
+nub add @elmohq/sdk
+```
+
+```sh
+vlt install @elmohq/sdk
+```
+
+```sh
+aube add @elmohq/sdk
+```
+
+</details>
+
+## Usage
+
+Set `ELMO_API_KEY` in your environment, then call the API:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo();
+const data = await elmo.brands.list();
+
+console.log(data);
+```
+
+## Requirements
+
+- Node.js 20.19 or later
+- TypeScript 5.5 or later, for its types, and 5.8 or later to `require()` it from CommonJS
+
+## Pagination
+
+Iterate a paginated call to read every item. Each page is fetched when the loop reaches it.
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo();
+for await (const item of elmo.brands.list()) {
+  console.log(item);
+}
+```
+
+## Errors
+
+When the API answers with an error status, the call throws `APIError`, or a subclass named for the status. `requestId` holds the id to quote when you report a failure. Every error the SDK throws extends `ElmoError`.
+
+```ts
+import { APIError, Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo();
+try {
+  await elmo.brands.list();
+} catch (error) {
+  if (error instanceof APIError) {
+    console.log(error.status, error.requestId, error.body);
+  } else {
+    throw error;
+  }
+}
+```
+
+To handle a failure without `try`, call `.result()`. It resolves with `ok: false` and a typed `error`. Checking `result.status` narrows `error.body` to the body the API description declares for that status.
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo();
+const result = await elmo.brands.list().result();
+if (!result.ok) {
+  if (result.status === 401) {
+    console.log(result.error.body);
+  } else {
+    console.log(result.error);
+  }
+}
+```
+
+Catch one status by its class:
+
+| Status                 | Error                      |
+| ---------------------- | -------------------------- |
+| 400                    | `BadRequestError`          |
+| 401                    | `AuthenticationError`      |
+| 402                    | `PaymentRequiredError`     |
+| 403                    | `PermissionDeniedError`    |
+| 404                    | `NotFoundError`            |
+| 409                    | `ConflictError`            |
+| 422                    | `UnprocessableEntityError` |
+| 429                    | `RateLimitError`           |
+| 500 and above          | `InternalServerError`      |
+| Any other error status | `APIError`                 |
+
+A call that got no reply has no status. It throws `TransportError`, or `TimeoutError` where an attempt ran out of time. Neither is an `APIError`.
+
+A call made with no credential throws `MissingCredentialError` before anything is sent. A reply the SDK cannot read throws `DecodeError`. A call you cancel through `signal` throws `AbortError`.
+
+By the time a call throws `RateLimitError`, the client has sent it again up to 2 times. `retryAfterMs` on `RateLimitError` holds how long the API asked to wait, in milliseconds, where it said.
+
+To report a failure, [open an issue](https://github.com/elmohq/elmo-sdk-typescript/issues) and quote `requestId`.
+
+## Configuration
+
+### Authentication
+
+The client reads `ELMO_API_KEY` from the environment. To pass the value yourself, set `apiKey`:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ apiKey: '…' });
+```
+
+`apiKey` also takes a function that returns the value, such as one that reads it from a secret store. The client calls it for each request.
+
+### Browser usage
+
+This client refuses to build in a browser, where every visitor to the page can read the credential it sends. Build it on a server instead. Pass `dangerouslyAllowBrowser: true` only where the credential is meant to be public, or a proxy adds it.
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ dangerouslyAllowBrowser: true });
+```
+
+### Base URL
+
+Calls go to `/api/v1`. To send them elsewhere, such as a proxy or a gateway, set `baseURL`, or the `ELMO_BASE_URL` environment variable:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ baseURL: 'https://gateway.example.com' });
+```
+
+### Per-call options
+
+One call can run under settings of its own. `withOptions` returns a client that differs only in what you pass, and takes every option the client does. Headers merge per name, and every other option replaces the client's:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo();
+await elmo.withOptions({ timeout: 5000, maxRetries: 0 }).brands.list();
+```
+
+A call also takes the same settings as its last argument.
+
+### Retries
+
+A failed call is sent again up to 2 times, after a lost connection, a 408, 425 or 429 status, or most 5xx statuses. A `POST` or `PATCH` call may already have changed something, so it is sent again only after a request that never reached the API or a 408, 425 or 429 status.
+
+Each wait is longer than the last on average, or as long as `Retry-After` asks.
+
+To change that count, set `maxRetries` on the client or on one call. For every other rule, such as which failures are retried and how long each wait is, set `retry`, which takes a `RetryOptions`:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ maxRetries: 5 });
+await elmo.withOptions({ maxRetries: 0 }).brands.list();
+```
+
+To wait longer between attempts, set the first wait and the longest one:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ retry: { delay: 1000, maxDelay: 10000 } });
+```
+
+### Timeouts
+
+Each attempt may run for 60 seconds. One that runs longer throws `TimeoutError`. To change the limit, set `timeout` in milliseconds on the client or on one call. `false` removes it:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ timeout: 20_000 });
+await elmo.withOptions({ timeout: 5000 }).brands.list();
+```
+
+### Logging
+
+Logging is off by default. To see what the SDK sends and receives, set `logLevel` or the `ELMO_LOG` environment variable. `'info'` logs each call and its reply, and `'debug'` adds headers, with credentials redacted. Bodies are never logged. Logs go to `console` unless you pass a `logger`.
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ logLevel: 'info' });
+```
+
+### Custom fetch
+
+To send requests through a proxy, with other TLS options or over HTTP/2, pass a `fetch` of your own. It is called with the URL as a string and a `RequestInit`, and returns a `Response`, so it can wrap the global one or call a library's. To add `RequestInit` fields to every request instead, such as `credentials`, pass `fetchOptions`.
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({
+  fetch: async (input, init) => {
+    const started = performance.now();
+    const response = await fetch(input, init);
+    console.log(input, response.status, performance.now() - started);
+    return response;
+  },
+});
+```
+
+### Default headers
+
+To send a header with every call, set `defaultHeaders` on the client. A call's own `headers` are merged with them by name, and `null` drops one:
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({ defaultHeaders: { 'x-team': 'billing' } });
+```
+
+### Interceptors
+
+To run code of your own around every call, set `interceptors` on the client. A `request` hook runs on each request last before it is sent, with the credential already on it. A `response` hook returns the result the caller reads, and an `error` hook returns the error the caller gets, so a hook that only observes returns what it was given. Hooks run in the order you list them.
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo({
+  interceptors: {
+    request: [
+      (request) => {
+        request.meta['x-request-source'] = 'worker';
+      },
+    ],
+  },
+});
+```
+
+### Raw response
+
+To read the HTTP response as well, call `.withResponse()` on a call. What comes back holds:
+
+- `data`: what the call resolves with on its own
+- `response`: the `Response` that carried it, for a header or a field the SDK does not model
+- `requestId`: the id to quote when you report a problem
+
+```ts
+import { Elmo } from '@elmohq/sdk';
+
+const elmo = new Elmo();
+const reply = await elmo.me.get().withResponse();
+console.log(reply.response.status, reply.response.headers.get('content-type'));
+```
+
+`.asResponse()` resolves with the `Response` alone, with its body unread.
+
+### Environment variables
+
+The client reads each variable when its option is not set:
+
+| Variable        | Option     | Default     |
+| --------------- | ---------- | ----------- |
+| `ELMO_API_KEY`  | `apiKey`   |             |
+| `ELMO_BASE_URL` | `baseURL`  | `'/api/v1'` |
+| `ELMO_LOG`      | `logLevel` | `'off'`     |
+
+### Forward compatibility
+
+The API can add a field or a value after this version of the SDK is released. This version keeps working when that happens, and you can use the new part of the API before a release declares it.
+
+- A reply is handed back as the API sent it. A field, an enum value or a member of a union that this version does not declare is there to read, though the types do not name it.
+- To send a field this version does not declare, write it in the inputs beside the fields it does. TypeScript refuses a key it does not know in an object literal, so spread it in from an object of its own.
+
+### Bundle size
+
+Where bundle size matters, such as in a browser app, call a function from `@elmohq/sdk/calls` instead. A bundle keeps only the calls you import.
+
+```ts
+import { createElmoClient } from '@elmohq/sdk';
+import { brandsList } from '@elmohq/sdk/calls';
+
+const client = createElmoClient();
+await brandsList(client);
+```
+
+## License
+
+MIT. See [LICENSE.md](LICENSE.md).

package/dist/calls/index.d.mts

@@ -0,0 +1,288 @@
+import { a as PagePromise, g as Client, h as RestCallPromise, t as RequestOptions } from "../request-options-DWYI_Ldj.mjs";
+import { $ as GetOrganizationBillingResponses, At as UpdateCompetitorResponses, Cn as ListBrandCitationURLsErrors, Ct as GetCompetitorErrors, D as ListPromptsErrors, Dn as ListBrandPromptPerformanceParams, E as GetPromptResponses, En as ListBrandPromptPerformanceErrors, Et as ListCompetitorsParams, Ft as CreateBrandResponses, G as ListPromptRunsParams, H as GetRunErrors, Ht as UpdateBrandParams, I as GetPromptSnapshotErrors, It as GetBrandErrors, L as GetPromptSnapshotParams, Lt as GetBrandResponses, M as UpdatePromptErrors, Mt as BrandsList, N as UpdatePromptParams, Nt as CreateBrandErrors, O as ListPromptsParams, On as ListBrandPromptPerformanceResponses, Ot as UpdateCompetitorErrors, P as UpdatePromptResponses, Pt as CreateBrandParams, Q as GetOrganizationBillingErrors, R as GetPromptSnapshotResponses, Rt as ListBrandsErrors, S as DeletePromptErrors, Sn as ListBrandCitationDomainsResponses, St as DeleteCompetitorResponses, T as GetPromptErrors, Tn as ListBrandCitationURLsResponses, Tt as ListCompetitorsErrors, U as GetRunResponses, Ut as UpdateBrandResponses, Vt as UpdateBrandErrors, W as ListPromptRunsErrors, X as RunSummary, Xt as ListBrandTagsResponses, Y as RunList, Yt as ListBrandTagsErrors, _n as GetBrandQueryFanoutErrors, _t as CompetitorsList, a as CreateReportErrors, an as BrandIdPath, at as Organization, b as CreatePromptParams, bn as ListBrandCitationDomainsErrors, bt as CreateCompetitorResponses, c as CreateReportResponses, et as GetOrganizationErrors, f as GetReportResponses, gn as GetBrandAnalyticsResponses, gt as Competitor, h as ListReportsResponse, hn as GetBrandAnalyticsParams, ht as GetMeResponses, j as Prompt, jt as Brand, k as ListPromptsResponse, kt as UpdateCompetitorParams, l as GetReportErrors, lt as ListModelsErrors, m as ListReportsParams, mn as GetBrandAnalyticsErrors, mt as GetMeErrors, n as AnalyzeBrandParams, nn as GetBrandOpportunitiesResponses, nt as ListOrganizationsErrors, o as CreateReportParams, p as ListReportsErrors, r as AnalyzeBrandResponses, rt as ListOrganizationsParams, st as OrganizationList, t as AnalyzeBrandErrors, tn as GetBrandOpportunitiesErrors, tt as GetOrganizationResponses, u as GetReportParams, ut as ListModelsResponses, v as ReportSummary, vn as GetBrandQueryFanoutParams, vt as CreateCompetitorErrors, w as DeletePromptResponses, wn as ListBrandCitationURLsParams, wt as GetCompetitorResponses, x as CreatePromptResponses, xn as ListBrandCitationDomainsParams, xt as DeleteCompetitorErrors, y as CreatePromptErrors, yn as GetBrandQueryFanoutResponses, yt as CreateCompetitorParams, zt as ListBrandsParams } from "../tools-7Hs5J2xb.mjs";
+//#region src/calls/brands-analytics-get.d.ts
+/**
+ * Get a brand's analytics
+ *
+ * Visibility, share of voice, the per-model breakdown and the citation totals for one window, in
+ * one request.
+ *
+ * The long lists — cited domains and URLs, sub-queries, per-prompt results — are endpoints of their
+ * own. Everything else is always included.
+ */
+declare function brandsAnalyticsGet(client: Client, brandId: BrandIdPath, params: GetBrandAnalyticsParams, options?: RequestOptions): RestCallPromise<GetBrandAnalyticsResponses, GetBrandAnalyticsErrors>;
+//#endregion
+//#region src/calls/brands-citations-domains-list.d.ts
+/**
+ * List cited domains
+ *
+ * Domains the engines cited when answering this brand's prompts, categorized and compared against
+ * the equal-length window immediately before this one.
+ */
+declare function brandsCitationsDomainsList(client: Client, brandId: BrandIdPath, params: ListBrandCitationDomainsParams, options?: RequestOptions): RestCallPromise<ListBrandCitationDomainsResponses, ListBrandCitationDomainsErrors>;
+//#endregion
+//#region src/calls/brands-citations-urls-list.d.ts
+/**
+ * List cited URLs
+ *
+ * Individual pages the engines cited, with their category and page type.
+ */
+declare function brandsCitationsURLsList(client: Client, brandId: BrandIdPath, params: ListBrandCitationURLsParams, options?: RequestOptions): RestCallPromise<ListBrandCitationURLsResponses, ListBrandCitationURLsErrors>;
+//#endregion
+//#region src/calls/brands-create.d.ts
+/** Create a brand */
+declare function brandsCreate(client: Client, params: CreateBrandParams, options?: RequestOptions): RestCallPromise<CreateBrandResponses, CreateBrandErrors>;
+//#endregion
+//#region src/calls/brands-get.d.ts
+/** Get a brand */
+declare function brandsGet(client: Client, brandId: string, options?: RequestOptions): RestCallPromise<GetBrandResponses, GetBrandErrors>;
+//#endregion
+//#region src/calls/brands-list.d.ts
+declare function brandsList(client: Client, params?: ListBrandsParams, options?: RequestOptions): PagePromise<Brand, BrandsList, ListBrandsErrors>;
+//#endregion
+//#region src/calls/brands-opportunities-get.d.ts
+/**
+ * Get the latest opportunities report
+ *
+ * **Experimental — the response shape may still change.**
+ *
+ * The brand's Opportunities report: a prioritized set of ways to get cited more often, with the
+ * tracked prompts and cited pages behind each one. The same analysis the dashboard shows, from the
+ * same code.
+ *
+ * Generation is inline and synchronous. A stored report is served while it is fresh and regenerated
+ * when it is not, so there is nothing to poll for and no way to be handed a stale one — but a
+ * request that triggers a generation waits for it. The freshness window bounds the cost: however
+ * many callers ask, one generation per brand per window. There is deliberately no `POST`, which
+ * would spend provider budget with nothing metering it per call.
+ *
+ * @experimental
+ */
+declare function brandsOpportunitiesGet(client: Client, brandId: BrandIdPath, options?: RequestOptions): RestCallPromise<GetBrandOpportunitiesResponses, GetBrandOpportunitiesErrors>;
+//#endregion
+//#region src/calls/brands-prompt-performance-list.d.ts
+/**
+ * List prompt performance
+ *
+ * Per-prompt mention rates over the window. The analytics counterpart to `GET /prompts?brandId=`,
+ * which returns prompt configuration rather than results.
+ *
+ * A prompt the brand stopped tracking is not sampled, so it has no results over the window and does
+ * not appear here.
+ */
+declare function brandsPromptPerformanceList(client: Client, brandId: BrandIdPath, params: ListBrandPromptPerformanceParams, options?: RequestOptions): RestCallPromise<ListBrandPromptPerformanceResponses, ListBrandPromptPerformanceErrors>;
+//#endregion
+//#region src/calls/brands-query-fanout-get.d.ts
+/**
+ * Get query fan-out
+ *
+ * The searches engines ran while answering this brand's prompts. Engines that don't expose their
+ * searches still contribute runs, so `coverageRate` is the honest denominator.
+ */
+declare function brandsQueryFanoutGet(client: Client, brandId: BrandIdPath, params: GetBrandQueryFanoutParams, options?: RequestOptions): RestCallPromise<GetBrandQueryFanoutResponses, GetBrandQueryFanoutErrors>;
+//#endregion
+//#region src/calls/brands-tags-list.d.ts
+/**
+ * List a brand's tags
+ *
+ * Every tag in use on the brand's prompts, with how many carry each — enough to build the same
+ * filter the dashboard shows without paging the whole prompt list to derive it.
+ *
+ * Tags are not a resource of their own: a tag exists exactly as long as some prompt carries it.
+ * `branded` and `unbranded` are computed by Elmo and always listed.
+ */
+declare function brandsTagsList(client: Client, brandId: BrandIdPath, options?: RequestOptions): RestCallPromise<ListBrandTagsResponses, ListBrandTagsErrors>;
+//#endregion
+//#region src/calls/brands-update.d.ts
+/** Update a brand */
+declare function brandsUpdate(client: Client, brandId: string, params: UpdateBrandParams, options?: RequestOptions): RestCallPromise<UpdateBrandResponses, UpdateBrandErrors>;
+//#endregion
+//#region src/calls/competitors-create.d.ts
+/** Add a competitor */
+declare function competitorsCreate(client: Client, params: CreateCompetitorParams, options?: RequestOptions): RestCallPromise<CreateCompetitorResponses, CreateCompetitorErrors>;
+//#endregion
+//#region src/calls/competitors-delete.d.ts
+/** Delete a competitor */
+declare function competitorsDelete(client: Client, competitorId: string, options?: RequestOptions): RestCallPromise<DeleteCompetitorResponses, DeleteCompetitorErrors>;
+//#endregion
+//#region src/calls/competitors-get.d.ts
+/** Get a competitor */
+declare function competitorsGet(client: Client, competitorId: string, options?: RequestOptions): RestCallPromise<GetCompetitorResponses, GetCompetitorErrors>;
+//#endregion
+//#region src/calls/competitors-list.d.ts
+declare function competitorsList(client: Client, params?: ListCompetitorsParams, options?: RequestOptions): PagePromise<Competitor, CompetitorsList, ListCompetitorsErrors>;
+//#endregion
+//#region src/calls/competitors-update.d.ts
+/** Update a competitor */
+declare function competitorsUpdate(client: Client, competitorId: string, params: UpdateCompetitorParams, options?: RequestOptions): RestCallPromise<UpdateCompetitorResponses, UpdateCompetitorErrors>;
+//#endregion
+//#region src/calls/me-get.d.ts
+/**
+ * Describe the calling key
+ *
+ * What this key is, which organization and brands it reaches, and which scopes it holds. Requires
+ * no scope, so it is always safe to call first when wiring up an integration.
+ */
+declare function meGet(client: Client, options?: RequestOptions): RestCallPromise<GetMeResponses, GetMeErrors>;
+//#endregion
+//#region src/calls/models-list.d.ts
+/**
+ * List trackable models
+ *
+ * The answer engines this deployment can track, so a client can build a model filter without
+ * hardcoding ids that differ between deployments.
+ *
+ * Requires no scope.
+ */
+declare function modelsList(client: Client, options?: RequestOptions): RestCallPromise<ListModelsResponses, ListModelsErrors>;
+//#endregion
+//#region src/calls/organizations-billing-get.d.ts
+/**
+ * Get billing state
+ *
+ * The organization's plan, its limits, and how much of each limit is already spent — enough for an
+ * integration to know a write will be rejected before attempting it.
+ *
+ * This endpoint is read-only by construction. No API key of any kind can change a subscription, an
+ * add-on quantity, or a payment method; there is no billing write endpoint and no billing write
+ * scope. Stripe identifiers, invoices, and payment methods are never returned.
+ *
+ * Deployments without billing answer `200` with `billingEnabled: false`, a null plan, and null
+ * limits, so callers need no special case.
+ */
+declare function organizationsBillingGet(client: Client, organizationId: string, options?: RequestOptions): RestCallPromise<GetOrganizationBillingResponses, GetOrganizationBillingErrors>;
+//#endregion
+//#region src/calls/organizations-get.d.ts
+/**
+ * Get an organization
+ *
+ * No scope required. An organization outside the key's reach answers `404`, identically to one that
+ * does not exist.
+ */
+declare function organizationsGet(client: Client, organizationId: string, options?: RequestOptions): RestCallPromise<GetOrganizationResponses, GetOrganizationErrors>;
+//#endregion
+//#region src/calls/organizations-list.d.ts
+/**
+ * One entry for an organization key — the one it acts inside. Every organization for an instance
+ * admin key. No scope required: a key can only ever see the organization it is already bound to.
+ */
+declare function organizationsList(client: Client, params?: ListOrganizationsParams, options?: RequestOptions): PagePromise<Organization, OrganizationList, ListOrganizationsErrors>;
+//#endregion
+//#region src/calls/prompts-create.d.ts
+/**
+ * Create a new prompt
+ *
+ * Create a new prompt for a brand. This will automatically schedule the prompt for execution.
+ */
+declare function promptsCreate(client: Client, params: CreatePromptParams, options?: RequestOptions): RestCallPromise<CreatePromptResponses, CreatePromptErrors>;
+//#endregion
+//#region src/calls/prompts-delete.d.ts
+/**
+ * Delete a prompt
+ *
+ * Permanently delete a prompt and cancel all related scheduled jobs. This will also cascade delete
+ * all associated prompt runs.
+ *
+ * Requires an instance admin key; organization keys receive `403`. The dashboard has no delete
+ * either — stop tracking a prompt with `promptsUpdate()` and `enabled: false`, which keeps its
+ * history and frees the plan slot.
+ */
+declare function promptsDelete(client: Client, promptId: string, options?: RequestOptions): RestCallPromise<DeletePromptResponses, DeletePromptErrors>;
+//#endregion
+//#region src/calls/prompts-get.d.ts
+/**
+ * Get a prompt
+ *
+ * Retrieve a specific prompt by ID
+ */
+declare function promptsGet(client: Client, promptId: string, options?: RequestOptions): RestCallPromise<GetPromptResponses, GetPromptErrors>;
+//#endregion
+//#region src/calls/prompts-list.d.ts
+/**
+ * List all prompts
+ *
+ * Retrieve a paginated list of all prompts across all brands
+ */
+declare function promptsList(client: Client, params?: ListPromptsParams, options?: RequestOptions): PagePromise<Prompt, ListPromptsResponse, ListPromptsErrors>;
+//#endregion
+//#region src/calls/prompts-runs-get.d.ts
+/**
+ * Get a run
+ *
+ * One model answer, with its text normalized out of the provider’s response and its citations in
+ * the order the engine listed them. A run belonging to some other prompt answers `404`. The
+ * provider’s raw payload is deliberately not exposed — its shape belongs to the provider, not to
+ * this API.
+ */
+declare function promptsRunsGet(client: Client, promptId: string, runId: string, options?: RequestOptions): RestCallPromise<GetRunResponses, GetRunErrors>;
+//#endregion
+//#region src/calls/prompts-runs-list.d.ts
+/**
+ * List runs for a prompt
+ *
+ * Individual model answers behind the aggregates, newest first, without their text — the list stays
+ * small enough to page through. Fetch `promptsRunsGet()` for the answer itself.
+ */
+declare function promptsRunsList(client: Client, promptId: string, params: ListPromptRunsParams, options?: RequestOptions): PagePromise<RunSummary, RunList, ListPromptRunsErrors>;
+//#endregion
+//#region src/calls/prompts-snapshot-get.d.ts
+/**
+ * Get an aggregated snapshot of mention and citation analytics for a specific prompt over a date
+ * range. Use this to identify competitive gaps, track brand visibility trends, and discover top
+ * cited URLs.
+ */
+declare function promptsSnapshotGet(client: Client, promptId: string, params: GetPromptSnapshotParams, options?: RequestOptions): RestCallPromise<GetPromptSnapshotResponses, GetPromptSnapshotErrors>;
+//#endregion
+//#region src/calls/prompts-update.d.ts
+/**
+ * Update a prompt
+ *
+ * Update a prompt's properties. Only provided fields will be updated. Toggling `enabled` schedules
+ * or unschedules the recurring run job.
+ */
+declare function promptsUpdate(client: Client, promptId: string, params: UpdatePromptParams, options?: RequestOptions): RestCallPromise<UpdatePromptResponses, UpdatePromptErrors>;
+//#endregion
+//#region src/calls/reports-create.d.ts
+/**
+ * Create a report
+ *
+ * Create a new AI Share of Voice report and queue it for generation. The report will evaluate the
+ * brand across multiple AI engines (ChatGPT, Claude, Google AI) using generated and optional custom
+ * prompts.
+ *
+ * Requires an instance admin key; organization keys receive `403`.
+ */
+declare function reportsCreate(client: Client, params: CreateReportParams, options?: RequestOptions): RestCallPromise<CreateReportResponses, CreateReportErrors>;
+//#endregion
+//#region src/calls/reports-get.d.ts
+/**
+ * Get report status and data
+ *
+ * Poll a report's status. When completed, returns per-prompt snapshot data with raw mention counts.
+ * Consumers are responsible for computing SoV and other derived metrics from the raw data.
+ *
+ * Requires an instance admin key; organization keys receive `403`.
+ */
+declare function reportsGet(client: Client, reportId: string, params?: GetReportParams, options?: RequestOptions): RestCallPromise<GetReportResponses, GetReportErrors>;
+//#endregion
+//#region src/calls/reports-list.d.ts
+/**
+ * Retrieve a paginated list of all reports, ordered by creation date (newest first).
+ *
+ * Requires an instance admin key; organization keys receive `403`.
+ */
+declare function reportsList(client: Client, params?: ListReportsParams, options?: RequestOptions): PagePromise<ReportSummary, ListReportsResponse, ListReportsErrors>;
+//#endregion
+//#region src/calls/tools-analyze.d.ts
+/**
+ * Analyze a website
+ *
+ * Run brand analysis without persisting anything. Returns suggested additional domains, aliases,
+ * competitors, and prompts.
+ *
+ * Requires an instance admin key; organization keys receive `403`.
+ */
+declare function toolsAnalyze(client: Client, params: AnalyzeBrandParams, options?: RequestOptions): RestCallPromise<AnalyzeBrandResponses, AnalyzeBrandErrors>;
+//#endregion
+export { brandsAnalyticsGet, brandsCitationsDomainsList, brandsCitationsURLsList, brandsCreate, brandsGet, brandsList, brandsOpportunitiesGet, brandsPromptPerformanceList, brandsQueryFanoutGet, brandsTagsList, brandsUpdate, competitorsCreate, competitorsDelete, competitorsGet, competitorsList, competitorsUpdate, meGet, modelsList, organizationsBillingGet, organizationsGet, organizationsList, promptsCreate, promptsDelete, promptsGet, promptsList, promptsRunsGet, promptsRunsList, promptsSnapshotGet, promptsUpdate, reportsCreate, reportsGet, reportsList, toolsAnalyze };
+//# sourceMappingURL=index.d.mts.map

package/dist/calls/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/calls/brands-analytics-get.ts","../../src/calls/brands-citations-domains-list.ts","../../src/calls/brands-citations-urls-list.ts","../../src/calls/brands-create.ts","../../src/calls/brands-get.ts","../../src/calls/brands-list.ts","../../src/calls/brands-opportunities-get.ts","../../src/calls/brands-prompt-performance-list.ts","../../src/calls/brands-query-fanout-get.ts","../../src/calls/brands-tags-list.ts","../../src/calls/brands-update.ts","../../src/calls/competitors-create.ts","../../src/calls/competitors-delete.ts","../../src/calls/competitors-get.ts","../../src/calls/competitors-list.ts","../../src/calls/competitors-update.ts","../../src/calls/me-get.ts","../../src/calls/models-list.ts","../../src/calls/organizations-billing-get.ts","../../src/calls/organizations-get.ts","../../src/calls/organizations-list.ts","../../src/calls/prompts-create.ts","../../src/calls/prompts-delete.ts","../../src/calls/prompts-get.ts","../../src/calls/prompts-list.ts","../../src/calls/prompts-runs-get.ts","../../src/calls/prompts-runs-list.ts","../../src/calls/prompts-snapshot-get.ts","../../src/calls/prompts-update.ts","../../src/calls/reports-create.ts","../../src/calls/reports-get.ts","../../src/calls/reports-list.ts","../../src/calls/tools-analyze.ts"],"mappings":"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"}