@elmohq/sdk 0.0.0-stage → 0.1.0

package/dist/request-options-DWYI_Ldj.d.mts

@@ -0,0 +1,1550 @@
+import { $ as GetOrganizationBillingResponses, $t as BrandOpportunities, A as ListPromptsResponses, An as PromptPerformance$1, At as UpdateCompetitorResponses, B as MentionEntry, Bn as WindowStart, Bt as ListBrandsResponses, C as DeletePromptResponse, Cn as ListBrandCitationURLsErrors, Ct as GetCompetitorErrors, D as ListPromptsErrors, Dn as ListBrandPromptPerformanceParams, Dt as ListCompetitorsResponses, E as GetPromptResponses, En as ListBrandPromptPerformanceErrors, Et as ListCompetitorsParams, F as CitedURLEntry, Fn as VisibilityPoint, Ft as CreateBrandResponses, G as ListPromptRunsParams, Gn as UnauthorizedError, Gt as Page$1, H as GetRunErrors, Hn as ForbiddenError, Ht as UpdateBrandParams, I as GetPromptSnapshotErrors, In as ValidationError, It as GetBrandErrors, J as RunCitation, Jt as PaymentRequiredError$1, K as ListPromptRunsResponses, Kt as Limit, L as GetPromptSnapshotParams, Ln as NotFoundError$1, Lt as GetBrandResponses, M as UpdatePromptErrors, Mn as ShareOfVoiceEntry, Mt as BrandsList, N as UpdatePromptParams, Nn as ShareOfVoicePoint, Nt as CreateBrandErrors, O as ListPromptsParams, On as ListBrandPromptPerformanceResponses, Ot as UpdateCompetitorErrors, P as UpdatePromptResponses, Pn as TagsFilter, Pt as CreateBrandParams, Q as GetOrganizationBillingErrors, Qt as TagList, R as GetPromptSnapshotResponses, Rn as ModelFilter, Rt as ListBrandsErrors, S as DeletePromptErrors, Sn as ListBrandCitationDomainsResponses, St as DeleteCompetitorResponses, T as GetPromptErrors, Tn as ListBrandCitationURLsResponses, Tt as ListCompetitorsErrors, U as GetRunResponses, Un as InternalServerError$1, Ut as UpdateBrandResponses, V as MentionsSummary, Vn as Error$1, Vt as UpdateBrandErrors, W as ListPromptRunsErrors, Wn as RateLimitError$1, Wt as Pagination, X as RunSummary, Xt as ListBrandTagsResponses, Y as RunList, Yt as ListBrandTagsErrors, Z as BillingPlan, Zt as Tag, _ as ReportPromptSnapshot, _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, cn as CitationDomain, ct as PlanLimits, d as GetReportResponse, dn as CitationURLList, dt as Model, en as CitedPage, et as GetOrganizationErrors, f as GetReportResponses, fn as DateRange, ft as ModelList, g as ListReportsResponses, gn as GetBrandAnalyticsResponses, gt as Competitor, h as ListReportsResponse, hn as GetBrandAnalyticsParams, ht as GetMeResponses, i as OnboardingSuggestion, in as OpportunityPrompt, it as ListOrganizationsResponses, j as Prompt, jn as PromptPerformanceList, jt as Brand, k as ListPromptsResponse, kn as ModelVisibility, kt as UpdateCompetitorParams, l as GetReportErrors, ln as CitationDomainList, lt as ListModelsErrors, m as ListReportsParams, mn as GetBrandAnalyticsErrors, mt as GetMeErrors, n as AnalyzeBrandParams, nn as GetBrandOpportunitiesResponses, nt as ListOrganizationsErrors, o as CreateReportParams, on as BrandAnalytics, ot as OrganizationBilling, p as ListReportsErrors, pn as FanoutQuery, pt as APIKeyIdentity, q as Run, qt as ConflictError$1, r as AnalyzeBrandResponses, rn as Opportunity, rt as ListOrganizationsParams, s as CreateReportResponse, sn as BrandQueryFanout, st as OrganizationList, t as AnalyzeBrandErrors, tn as GetBrandOpportunitiesErrors, tt as GetOrganizationResponses, u as GetReportParams, un as CitationURL, 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, z as PromptSnapshot, zn as WindowEnd, zt as ListBrandsParams } from "./tools-7Hs5J2xb.mjs";
+//#region src/internal/core/backoff.d.ts
+/**
+ * How much of each wait is random, so callers that failed together do not all
+ * come back at once.
+ *
+ * A number from 0 to 1 is the random share: `0.25` waits between three
+ * quarters of the computed wait and all of it. `'full'` is 1, `'equal'` is 0.5
+ * and `'none'` is 0. `true` is `'full'` and `false` is `'none'`.
+ */
+type Jitter = boolean | number | 'equal' | 'full' | 'none';
+/** How long the wait before each retry is. */
+interface BackoffOptions {
+  /**
+   * Base delay in milliseconds.
+   *
+   * @default 500
+   */
+  delay?: number;
+  /**
+   * The share of each delay that is random.
+   *
+   * @default 'full'
+   */
+  jitter?: Jitter;
+  /**
+   * Upper bound on any single delay, in milliseconds.
+   *
+   * @default 30_000
+   */
+  maxDelay?: number;
+  /**
+   * How the wait grows. `'exponential'` doubles the base delay each time, up
+   * to `maxDelay`. `'constant'` waits the base delay every time.
+   *
+   * @default 'exponential'
+   */
+  strategy?: 'constant' | 'exponential';
+}
+/** A header the API may name its own wait in, and how to read its value. */
+interface RetryAfterHeader {
+  /**
+   * Whether a number counts forward from now, or names a moment.
+   *
+   * @default 'duration'
+   */
+  readonly kind?: 'duration' | 'moment';
+  /** Header name, matched case-insensitively. */
+  readonly name: string;
+  /**
+   * What a number in this header counts in.
+   *
+   * @default 'second'
+   */
+  readonly unit?: 'millisecond' | 'second';
+}
+//#endregion
+//#region src/internal/core/errors.d.ts
+/** The base of every error this SDK throws, including one from a call that never arrived. */
+declare class ElmoError extends Error {
+  /** The class's name. Compare it where `instanceof` fails, such as across two copies of this SDK. */
+  name: string;
+}
+/** Thrown before the request goes out, when no credential satisfied the call. */
+declare class MissingCredentialError extends ElmoError {
+  readonly name = "MissingCredentialError";
+  /** Credential options that would have satisfied the call. */
+  readonly schemes: ReadonlyArray<string>;
+  constructor(message: string, schemes?: ReadonlyArray<string>);
+}
+/**
+ * Thrown when the caller called the request off before the API answered.
+ *
+ * Not a {@link TransportError}, so code that retries or reports a failed
+ * connection leaves a call the caller cancelled alone.
+ */
+declare class AbortError extends ElmoError {
+  constructor(cause?: unknown);
+}
+/** Which way a {@link TransportError} failed. `connect` and `other` have no class of their own. */
+type TransportErrorKind = 'connect' | 'other' | 'timeout';
+/**
+ * A request that got no whole reply, as its transport states it.
+ *
+ * A transport rejects with one, or with a {@link TransportError} built from
+ * one. Any other rejection is read by its name and code.
+ */
+interface TransportFailure {
+  /** `true` where the request was called off, not lost. */
+  aborted: boolean;
+  /** What the library underneath threw. */
+  cause?: unknown;
+  /**
+   * Whether the API can have acted on the request. After `'no'`, the call is
+   * safe to send again, whatever its method.
+   */
+  reachedServer: 'maybe' | 'no' | 'yes';
+  /** How far the request got. */
+  stage: 'connect' | 'receive' | 'resolve' | 'send' | 'tls';
+}
+/** Thrown when no whole answer arrived, so there is no reply to go on. */
+declare class TransportError extends ElmoError {
+  readonly kind: TransportErrorKind;
+  /**
+   * Whether the API can have acted on the request. After `'no'`, the call is
+   * safe to send again, whatever its method.
+   */
+  readonly reachedServer: TransportFailure['reachedServer'];
+  /** How far the request got. */
+  readonly stage: TransportFailure['stage'];
+  constructor(failure: TransportErrorKind | TransportFailure, cause?: unknown, message?: string);
+}
+/**
+ * Thrown when a call waited on the API for as long as it allowed, from sending
+ * the request to the last byte of the reply.
+ *
+ * A reply with status 408 is an {@link APIError}, not one of these.
+ */
+declare class TimeoutError extends TransportError {
+  /** Milliseconds the call was allowed to wait on the API. */
+  readonly timeoutMs: number | undefined;
+  constructor(timeout?: number, cause?: unknown, target?: string);
+}
+/** The body of a failure, as the API description declares it. */
+type FailureBody = Error$1;
+/** A failure the API answered with, so there is a status and a reply to read. */
+declare class APIError<TBody = FailureBody> extends ElmoError {
+  /**
+   * The decoded failure body. `undefined` where the reply carried none, or
+   * carried text such as a proxy's page, which is in {@link APIError.text}.
+   */
+  readonly body: TBody | undefined;
+  /** The API's own error code, read from the failure body. `undefined` where it carried none. */
+  readonly code: string | number | undefined;
+  readonly headers: Headers;
+  /** The request id to quote when reporting this failure. */
+  readonly requestId: string | undefined;
+  /**
+   * The reply that carried this failure. Its body is already read, so take it
+   * from {@link APIError.body} or {@link APIError.text}.
+   */
+  readonly response: Response;
+  /** Milliseconds the API asked to wait before trying again. */
+  readonly retryAfterMs: number | undefined;
+  readonly status: number;
+  /**
+   * The failure body where the API sent text rather than JSON, such as a
+   * proxy's page. The message holds only its start.
+   */
+  readonly text: string | undefined;
+  constructor(status: number, body: unknown, response: Response, note?: string);
+}
+/** A reply from the API that this SDK could not read, whatever its status. */
+declare class DecodeError extends ElmoError {
+  /** Where the value sat, or absent where the whole reply failed. */
+  readonly at: string | undefined;
+  /** The request id to quote when reporting this failure. */
+  readonly requestId: string | undefined;
+  /** The reply. Its body is already read. */
+  readonly response: Response | undefined;
+  /** The reply's status. `undefined` where there is no {@link DecodeError.response}. */
+  readonly status: number | undefined;
+  /** What the API sent. The message holds only a short form of it. */
+  readonly value: unknown;
+  constructor(message: string, options?: {
+    at?: string | undefined;
+    cause?: unknown;
+    response?: Response | undefined;
+    value?: unknown;
+  });
+}
+//#endregion
+//#region src/internal/core/types.d.ts
+/** A request body in a form `fetch` sends as it is. */
+type BodyInput = NonNullable<RequestInit['body']>;
+/** An encoded request body, or `null` for a request that sends none. */
+type BodyPayload = BodyInput | null;
+/**
+ * One reply, as far as it has been read. Until its body is read, only `ok`,
+ * `response` and `status` are set.
+ */
+interface Result<TData = unknown, TError = unknown> {
+  /** The decoded body of a 2xx reply. */
+  data?: TData;
+  /** The decoded body of a reply that failed. */
+  error?: TError;
+  /** `true` for a 2xx status. */
+  ok?: boolean;
+  /** The reply itself, where one arrived. */
+  response?: Response;
+  status?: number;
+}
+interface CallLog {
+  ended(error?: unknown): void;
+  failed(error: unknown): void;
+  replied(response: Response | undefined): void;
+  retrying(wait: number, retry: number, retries: number, after?: Result): void;
+  sending(): void;
+}
+/** One way the API takes a credential, as the API description declares it. */
+interface AuthScheme {
+  /**
+   * Where the credential is sent.
+   *
+   * @default 'header'
+   */
+  readonly in?: 'cookie' | 'header' | 'query';
+  /** Which credential this is. Its option, where it has one, has the same name. */
+  readonly key?: string;
+  /** The header, query parameter or cookie the credential is sent in. */
+  readonly name?: string;
+  /** How an `http` credential is written in the `Authorization` header. */
+  readonly scheme?: 'basic' | 'bearer';
+  /**
+   * `'apiKey'` sends the credential as it is, where `in` and `name` say.
+   * `'http'` sends it in the `Authorization` header, written as `scheme` says.
+   */
+  readonly type: 'apiKey' | 'http';
+}
+type AuthRequirement = AuthScheme | ReadonlyArray<AuthScheme>;
+/** A time limit in milliseconds, or `false` for none. */
+type CallTimeout = number | false;
+interface InputRule {
+  readonly above?: number;
+  readonly below?: number;
+  readonly max?: number;
+  readonly min?: number;
+  readonly name?: string;
+  readonly of?: 'characters' | 'entries' | 'items';
+}
+type Interaction = 'unary';
+type PaginationStyle = 'cursor' | 'link' | 'offset' | 'page';
+interface PaginationDescriptor {
+  readonly cursor?: string;
+  readonly in?: 'body' | 'query';
+  readonly items?: string;
+  readonly limitParam?: string;
+  readonly link?: string;
+  readonly more?: string;
+  readonly pages?: string;
+  readonly param?: string;
+  readonly size?: string;
+  readonly start?: number;
+  readonly style: PaginationStyle;
+  readonly total?: string;
+}
+/** How a failed call is sent again. Anything left out keeps the client's rule. */
+interface RetryRules extends BackoffOptions {
+  /**
+   * How long a call may keep trying, in milliseconds, counted from the first
+   * attempt with the waits included. A retry that would start past it is not
+   * sent, and the last reply or error stands. An attempt that is running is
+   * not cut short: `timeout` limits each one.
+   *
+   * @default no limit
+   */
+  budget?: number;
+  /**
+   * How many times a failed call is sent again, after the first attempt.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+  /**
+   * The longest wait the API may ask for, in milliseconds. Past it, the call
+   * gives up and returns the reply as it is.
+   *
+   * @default 60_000
+   */
+  maxRetryAfter?: number;
+  /**
+   * Methods that may be sent again. A failure that never reached the server,
+   * a call carrying its API's idempotency key, and 408, 425 and 429 are sent
+   * again whatever this says.
+   *
+   * @default idempotent methods
+   */
+  methods?: ReadonlyArray<string>;
+  /**
+   * Headers the API may name its own wait in, read before the backoff
+   * applies. `false` reads none.
+   *
+   * @default `retry-after-ms`, `retry-after`, `x-ratelimit-reset-after`,
+   * `x-ratelimit-reset` and `x-rate-limit-reset`, in that order
+   */
+  retryAfter?: ReadonlyArray<RetryAfterHeader> | boolean;
+  /**
+   * Send the request again when an attempt runs past its deadline.
+   *
+   * @default false
+   */
+  retryOnTimeout?: boolean;
+  /**
+   * Statuses worth another attempt. A reply with `x-should-retry: false` is
+   * never retried.
+   */
+  statuses?: ReadonlyArray<number>;
+}
+interface ParameterSerialization {
+  readonly allowReserved?: boolean;
+  readonly array?: {
+    readonly explode?: boolean;
+    readonly style?: string;
+  };
+  readonly mediaType?: string;
+  readonly object?: {
+    readonly explode?: boolean;
+    readonly style?: string;
+  };
+}
+interface SerializationDescriptor {
+  readonly query?: Readonly<Record<string, ParameterSerialization>>;
+}
+interface CallableDescriptor {
+  readonly accept?: string;
+  readonly address: string;
+  readonly auth?: ReadonlyArray<AuthRequirement>;
+  readonly authOptional?: boolean;
+  readonly baseURL?: string;
+  readonly deprecated?: boolean;
+  readonly idempotency?: string;
+  readonly interaction?: Interaction;
+  readonly mediaType?: string;
+  readonly method?: string;
+  readonly pagination?: PaginationDescriptor;
+  readonly retry?: RetryRules | false;
+  /** `'json'` where every success is declared as a JSON object or list. */
+  readonly returns?: 'json';
+  readonly rules?: ReadonlyArray<InputRule>;
+  readonly serialization?: SerializationDescriptor;
+  readonly timeout?: CallTimeout;
+  readonly validators?: unknown;
+}
+type MetadataValue = string | Array<string> | undefined;
+type Metadata = Record<string, MetadataValue>;
+interface Credential {
+  in: 'cookie' | 'header' | 'query';
+  name: string;
+  value: string;
+}
+interface PlacedCredential {
+  readonly credential: Credential;
+  readonly scheme: AuthScheme;
+}
+type BodyOptions = {
+  /** The request body, before it is encoded. */
+  body?: unknown;
+};
+type SignalOptions = {
+  /** Cancels this call when it fires, retries included. */
+  signal?: AbortSignal;
+};
+type ExchangeOptions = BodyOptions & SignalOptions;
+/** A credential as a string, before it is written into the request. `undefined` sends none. */
+type AuthToken = string | undefined;
+/**
+ * Returns the credential to send for `scheme`, given the value its option
+ * holds. `undefined` sends none for that scheme.
+ */
+type AuthResolver = (scheme: AuthScheme, value: AuthToken) => Promise<AuthToken> | AuthToken;
+/** What the `auth` option takes: an {@link AuthResolver}, or `null` to send none. */
+type AuthValue = AuthResolver | null;
+type BodySerializerOptions = {
+  /**
+   * Encodes the request body, in place of the default for its content type.
+   * `null` sends the body as given.
+   */
+  bodySerializer?: ((body: unknown) => BodyPayload) | null;
+};
+type BaseURLOptions<TBaseURL = string> = {
+  /** The base URL for this call, in place of the client's. */
+  baseURL?: TBaseURL;
+};
+type CredentialOptions<TAuth = AuthValue> = {
+  /**
+   * Decides each credential a call sends, given the scheme and the value its
+   * option holds. What it returns is sent, so return the value to keep it.
+   * `null` sends no credential.
+   */
+  auth?: TAuth;
+};
+type EnvironmentOptions<TEnvironment = string> = {
+  /** Which environment to send to. `baseURL` wins over this. */
+  environment?: TEnvironment;
+};
+type ConnectionOptions<TBaseURL = string, TAuth = AuthValue, TEnvironment = string> = BaseURLOptions<TBaseURL> & CredentialOptions<TAuth> & ([TEnvironment] extends [never] ? unknown : EnvironmentOptions<TEnvironment>);
+/**
+ * How a failure reaches the caller.
+ *
+ * - `'throw'` resolves to the payload and throws the failure.
+ * - `'return'` resolves to the result envelope and throws no failure of the
+ *   call. What one of your own functions throws is still thrown.
+ */
+type ErrorMode = 'return' | 'throw';
+type ErrorOptions = {
+  /**
+   * Whether a failure is thrown or handed back beside the data. Set on a
+   * client's defaults, not per call.
+   *
+   * @default 'throw'
+   */
+  errors?: ErrorMode;
+};
+/** Headers as a `Headers`, as pairs of name and value, or as an object. */
+type MetadataInput = Headers | Iterable<readonly [string, string]> | Record<string, unknown>;
+/** What a call sends beside its body. Each member is merged per name. */
+type MetadataOptions = {
+  /** Headers to send. Merged per name, and `null` drops one. */
+  headers?: MetadataInput;
+  /** Path parameters. Merged per name. */
+  path?: Record<string, unknown>;
+  /** Query parameters to add. Merged per name, and `null` drops one. */
+  query?: Record<string, unknown>;
+};
+type SharedOptions<TAddress = string, TAuth = AuthValue, TEnvironment = string> = BodySerializerOptions & ConnectionOptions<TAddress, TAuth, TEnvironment> & ErrorOptions & MetadataOptions;
+type CallOptions = ExchangeOptions & SharedOptions;
+interface ResolvedOptions extends CallOptions {
+  [key: string]: unknown;
+  envelope?: boolean;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  raw?: boolean;
+  unread?: boolean;
+}
+/** A request about to be sent, which a `request` hook reads and may change. */
+interface PreparedRequest<TAddress = unknown> {
+  /** Where the request goes. Over HTTP, the whole URL, query string included. */
+  address: TAddress;
+  /** How many times this request was sent before. Unset on the first attempt. */
+  attempt?: number;
+  /** The request body, already encoded. */
+  body: BodyPayload | undefined;
+  /** The operation this request calls, as declared, `method` included. */
+  callable: CallableDescriptor;
+  /** How the call exchanges messages, such as one request for one reply. */
+  interaction: Interaction;
+  /** Where this call writes its log lines. Unset where the client does not log. */
+  log?: CallLog;
+  /** The headers to send, by lowercase name. */
+  meta: Metadata;
+  /** The options this call resolved to: the client's, with the call's own on top. */
+  options: ResolvedOptions;
+  /** Each credential put on the request, with the scheme it answers. */
+  placed?: ReadonlyArray<PlacedCredential>;
+  /**
+   * Set to `manual` by a feature that follows redirects itself. A transport
+   * that honors it hands back the redirect rather than following it.
+   */
+  redirect?: 'manual';
+  /** Calls the request off when it aborts. */
+  signal?: AbortSignal | undefined;
+  /** What to tell the caller where the API refuses a call sent with no credential. */
+  unauthenticated?: () => string;
+}
+/** The kinds of exchange a transport carries. `unary` is one request and one reply. */
+type TransportInteraction = 'unary';
+interface UnaryTransport<TAddress> {
+  /**
+   * Sends one request and resolves to the reply, whatever its status, with the
+   * body unread. Rejects only when no reply arrived.
+   */
+  unary(request: PreparedRequest<TAddress>): Promise<Response>;
+}
+type TransportMethods<TAddress> = UnaryTransport<TAddress>;
+/** What carries a request to the API and hands back what the API sends. */
+type Transport<TAddress, TInteraction extends TransportInteraction> = {
+  /** The transport's name, as an error message shows it. */
+  readonly name: string;
+} & Pick<TransportMethods<TAddress>, TInteraction>;
+/** A credential, or a function that returns one when a call needs it. */
+type CredentialValue = AuthToken | (() => Promise<AuthToken> | AuthToken);
+interface Codec {
+  readonly contentType: string | undefined;
+  decode?(raw: Response): Promise<unknown>;
+  encode(value: unknown): BodyPayload;
+  readonly mediaTypes: ReadonlyArray<string>;
+  readonly name: string;
+}
+type AnyTransport<TAddress = unknown> = {
+  readonly name: string;
+} & Partial<TransportMethods<TAddress>>;
+interface Binding<TAddress = unknown> {
+  /** What a request asks for where neither its call nor its client says. */
+  readonly accept?: string;
+  applyAuth(credential: Credential, request: PreparedRequest<TAddress>): void;
+  readonly name: string;
+  readError?(result: Result, request: PreparedRequest<TAddress>): unknown;
+  readResult?(raw: Response, request: PreparedRequest<TAddress>, codecs: ReadonlyArray<Codec>): Promise<Result>;
+  resolveAddress(callable: CallableDescriptor, options: ResolvedOptions): TAddress;
+}
+interface FeatureContext {
+  binding: Binding;
+  transport: AnyTransport;
+}
+type Send = (request: PreparedRequest) => Promise<Result>;
+interface Feature {
+  readonly name: string;
+  onError?(error: unknown, request: PreparedRequest, ctx: FeatureContext): unknown;
+  onOpen?(request: PreparedRequest, next: Send, ctx: FeatureContext): Promise<Result>;
+  onOptions?(options: ResolvedOptions, callable: CallableDescriptor, ctx: FeatureContext): Promise<void> | void;
+  onPrepare?(request: PreparedRequest, ctx: FeatureContext): Promise<void> | void;
+  onRequest?(request: PreparedRequest, ctx: FeatureContext): Promise<void> | void;
+  onResult?(result: Result, request: PreparedRequest, ctx: FeatureContext): Promise<Result> | Result;
+  onSend?(request: PreparedRequest, next: Send, ctx: FeatureContext): Promise<Result>;
+}
+type CredentialSpec = {
+  readonly option?: false;
+  readonly prefix?: string;
+  readonly variable?: string;
+};
+type Hundred = 3 | 4 | 5;
+type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type NumberOf<T> = T extends `${infer N extends number}` ? N : never;
+type Tens = { [H in Hundred]: { [T in Digit]: NumberOf<`${H}${T}${Digit}`>; }; };
+type Block = { [H in Hundred]: Tens[H][Digit]; };
+type SplitDigits<TText> = TText extends `${infer H}${infer T}${string}` ? [NumberOf<H>, NumberOf<T>] : never;
+type DigitsOf<TStatus> = TStatus extends number ? SplitDigits<`${TStatus}`> : never;
+type LeftIn<H extends Hundred, TExact> = H extends DigitsOf<TExact>[0] ? { [T in Digit]: [H, T] extends DigitsOf<TExact> ? Exclude<Tens[H][T], TExact> : Tens[H][T]; }[Digit] : Block[H];
+type Left<THundreds, TExact> = THundreds extends Hundred ? LeftIn<THundreds, TExact> : never;
+type RangeDigit<TKey> = TKey extends `${infer D extends number}${'X' | 'x'}${'X' | 'x'}` ? D & Hundred : never;
+type Open<TErrors> = Exclude<Hundred, RangeDigit<keyof TErrors>>;
+type StatusKey<TKey> = TKey extends number ? TKey : NumberOf<TKey>;
+type DefaultStatus<TErrors> = Left<Open<TErrors>, StatusKey<keyof TErrors>> & number;
+type RangeStatus<TErrors, TKey> = Left<RangeDigit<TKey>, StatusKey<keyof TErrors>> & number;
+type FailureStatusOf<TErrors, TKey> = TKey extends number ? TKey : TKey extends `${infer N extends number}` ? N : Lowercase<TKey & string> extends 'default' ? DefaultStatus<TErrors> : RangeStatus<TErrors, TKey>;
+type UndeclaredStatus<TErrors> = ('default' extends Lowercase<Extract<keyof TErrors, string>> ? 0 : 0 | Left<Open<TErrors>, StatusKey<keyof TErrors>>) & number;
+type ErrorOf<TErrors> = (TErrors extends object ? { [K in keyof TErrors]: {
+  data?: never;
+  error: APIError<TErrors[K]>;
+  ok: false;
+  status: FailureStatusOf<TErrors, K>;
+}; }[keyof TErrors] : never) | {
+  data?: never;
+  error: APIError;
+  ok: false;
+  status: UndeclaredStatus<TErrors>;
+};
+type StatusOf<TKey> = TKey extends number ? TKey : number;
+type OutputOf<TResponses> = TResponses extends object ? { [K in keyof TResponses]: {
+  data: TResponses[K];
+  error?: never;
+  ok: true;
+  status: StatusOf<K>;
+}; }[keyof TResponses] : Result;
+type UnansweredOf = {
+  data?: never;
+  error: ElmoError;
+  ok: false;
+  status?: undefined;
+};
+/**
+ * What awaiting a call gives back: the payload, or the whole result where the
+ * client returns a failure in place of throwing it.
+ */
+type CallResult<TResponses = unknown, TErrors = unknown, TMode extends ErrorMode = 'throw'> = TMode extends 'return' ? ErrorOf<TErrors> | OutputOf<TResponses> | UnansweredOf : TResponses extends object ? TResponses[keyof TResponses] : unknown;
+type PageOptions = {
+  /**
+   * Where to start reading, from an earlier page's `nextPageParam`. Unset, the
+   * walk starts at the page the call's own arguments name.
+   */
+  pageParam?: unknown;
+};
+/** What `result()` gives back: the payload, or the failure as a value. */
+type ResultEnvelope<TResponses = unknown, TErrors = unknown> = CallResult<TResponses, TErrors, 'return'>;
+/** What a paged call hands back when its failure is read rather than thrown. */
+type PageEnvelope<TAwaited = unknown, TErrors = unknown> = ErrorOf<TErrors> | UnansweredOf | {
+  data: TAwaited;
+  error?: never;
+  ok: true;
+  status: number;
+};
+/**
+ * What awaiting a paged call gives back: the page, or the whole result where
+ * the client returns a failure in place of throwing it.
+ */
+type PageResult<TAwaited = unknown, TErrors = unknown, TMode extends ErrorMode = 'throw'> = TMode extends 'return' ? PageEnvelope<TAwaited, TErrors> : TAwaited;
+//#endregion
+//#region src/internal/core/protocol.d.ts
+type Protocol = 'channel' | 'rest' | 'websocket';
+interface ProtocolSetup {
+  binding: Binding;
+  transport: AnyTransport;
+}
+type Protocols = Partial<Record<Protocol, ProtocolSetup>>;
+//#endregion
+//#region src/internal/core/dispatch.d.ts
+interface DispatchSetup {
+  accept?: string;
+  aliases?: Readonly<Record<string, string>>;
+  codecs: ReadonlyArray<Codec>;
+  credentials?: Readonly<Record<string, CredentialSpec>>;
+  defaults: ResolvedOptions;
+  env?: Readonly<Record<string, string>>;
+  features?: ReadonlyArray<Feature>;
+  guard?: (options: ResolvedOptions) => void;
+  protocols: Protocols;
+  transports?: (name: string) => AnyTransport;
+}
+interface Exchange {
+  read(from?: Response): Promise<unknown>;
+  requestId(): string | undefined;
+  readonly response: Response | undefined;
+}
+//#endregion
+//#region src/internal/core/client.d.ts
+/** What every call is sent through. It holds the options all calls share. */
+interface Client {
+  /** @internal */
+  call<TData = unknown, TError = unknown, TMode extends ErrorMode = 'throw'>(callable: CallableDescriptor, options?: ResolvedOptions): Promise<CallResult<TData, TError, TMode>>;
+  /** @internal */
+  exchange(callable: CallableDescriptor, options?: ResolvedOptions): Promise<Exchange>;
+  /** @internal */
+  prepare<TAddress = unknown>(callable: CallableDescriptor, options?: ResolvedOptions): Promise<PreparedRequest<TAddress>>;
+  /** @internal */
+  resolveAddress<TAddress = unknown>(callable: CallableDescriptor, options?: ResolvedOptions): TAddress;
+  /** @internal */
+  readonly setup: DispatchSetup;
+}
+//#endregion
+//#region src/internal/core/lazy-promise.d.ts
+declare abstract class LazyPromise<T> extends Promise<T> {
+  private answer;
+  constructor();
+  protected abstract settle(): Promise<T>;
+  private answered;
+  then<TResolved = T, TCaught = never>(onFulfilled?: ((value: T) => PromiseLike<TResolved> | TResolved) | null, onRejected?: ((reason: unknown) => PromiseLike<TCaught> | TCaught) | null): Promise<TCaught | TResolved>;
+  catch<TCaught = never>(onRejected?: ((reason: unknown) => PromiseLike<TCaught> | TCaught) | null): Promise<T | TCaught>;
+  finally(onFinally?: (() => void) | null): Promise<T>;
+  static get [Symbol.species](): PromiseConstructor;
+}
+//#endregion
+//#region src/internal/core/call-promise.d.ts
+/** A call already sent, whose reply is not yet read. */
+declare class CallPromise<TResponses = unknown, TErrors = unknown, TMode extends ErrorMode = 'throw'> extends LazyPromise<CallResult<TResponses, TErrors, TMode>> {
+  protected readonly client: Client;
+  protected readonly exchange: Promise<Exchange>;
+  protected readonly options: ResolvedOptions;
+  private envelope;
+  constructor(client: Client, callable: CallableDescriptor, options?: ResolvedOptions);
+  /**
+   * The whole result envelope. A failure of the call is returned on it, not
+   * thrown. What one of your own functions throws, such as a hook, is thrown
+   * as it is.
+   */
+  result(): Promise<ResultEnvelope<TResponses, TErrors>>;
+  /** The payload alone, with a failure thrown rather than handed back. */
+  unwrap(): Promise<CallResult<TResponses, TErrors, 'throw'>>;
+  private read;
+  protected settle(): Promise<CallResult<TResponses, TErrors, TMode>>;
+  protected decode(): Promise<ResultEnvelope<TResponses, TErrors>>;
+}
+/** What a call resolves with where its `Response` is asked for as well. */
+interface WithResponse<TData> {
+  /** What the call resolves with on its own. */
+  data: TData;
+  /** The request id to quote when reporting a problem with the call. */
+  requestId: string | undefined;
+  /** The `Response` that carried `data`. Its body is already read. */
+  response: Response;
+}
+/** A call already sent, whose `Response` can be read as well as its payload. */
+declare class RestCallPromise<TResponses = unknown, TErrors = unknown, TMode extends ErrorMode = 'throw'> extends CallPromise<TResponses, TErrors, TMode> {
+  private claimed;
+  private unread;
+  /**
+   * The `Response` itself, with its body unread and yours to read once. An
+   * error status does not throw here. A call that got no response does.
+   */
+  asResponse(): Promise<Response>;
+  /** The decoded body, the `Response` that carried it, and the request id. */
+  withResponse(): Promise<WithResponse<CallResult<TResponses, TErrors, TMode>>>;
+  protected decode(): Promise<ResultEnvelope<TResponses, TErrors>>;
+  private claim;
+}
+//#endregion
+//#region src/internal/binding/rest/errors.d.ts
+/** The API could not read the request, so it did not act on it. */
+declare class BadRequestError extends APIError {
+  readonly name = "BadRequestError";
+  readonly status: 400;
+}
+/** No usable credential reached the API: it was missing, unreadable, or rejected. */
+declare class AuthenticationError extends APIError {
+  readonly name = "AuthenticationError";
+  readonly status: 401;
+}
+/** The plan or the quota on this account does not cover the call. */
+declare class PaymentRequiredError extends APIError {
+  readonly name = "PaymentRequiredError";
+  readonly status: 402;
+}
+/** The credential was accepted, but it does not grant this call. */
+declare class PermissionDeniedError extends APIError {
+  readonly name = "PermissionDeniedError";
+  readonly status: 403;
+}
+/** Nothing is at this address, or the credential may not see what is. */
+declare class NotFoundError extends APIError {
+  readonly name = "NotFoundError";
+  readonly status: 404;
+}
+/** The call collided with the resource's current state: a duplicate, or a concurrent change. */
+declare class ConflictError extends APIError {
+  readonly name = "ConflictError";
+  readonly status: 409;
+}
+/** The request was read, and its contents were rejected. */
+declare class UnprocessableEntityError extends APIError {
+  readonly name = "UnprocessableEntityError";
+  readonly status: 422;
+}
+/** Too many calls. {@link APIError.retryAfterMs} carries how long the API asked to wait. */
+declare class RateLimitError extends APIError {
+  readonly name = "RateLimitError";
+  readonly status: 429;
+}
+/** The API failed after accepting the call. Every status from 500 up arrives as this. */
+declare class InternalServerError extends APIError {
+  readonly name = "InternalServerError";
+}
+//#endregion
+//#region src/internal/feature/interceptors.d.ts
+/** Hooks of your own, run in order at three points in every call. */
+interface Interceptors {
+  /** Runs when a call fails. Return the error to raise, which may be another. */
+  error?: ReadonlyArray<(error: unknown, request: PreparedRequest) => unknown>;
+  /** Runs on the built request, last before it is sent. */
+  request?: ReadonlyArray<(request: PreparedRequest) => Promise<void> | void>;
+  /** Runs on the reply. Return the result to read, which may be another. */
+  response?: ReadonlyArray<(result: Result, request: PreparedRequest) => Promise<Result> | Result>;
+}
+//#endregion
+//#region src/internal/feature/logger.d.ts
+/** One method of a {@link Logger}: a message, then the values logged with it. */
+type LogFn = (message: string, ...rest: ReadonlyArray<unknown>) => void;
+/** Where log lines go, such as `console`. */
+interface Logger {
+  debug: LogFn;
+  error: LogFn;
+  info: LogFn;
+  warn: LogFn;
+}
+/**
+ * How much a client logs. `'error'` writes failed calls. `'warn'` adds a retry
+ * or a redirect. `'info'` adds a line per attempt, with its status and time.
+ * `'debug'` adds headers, with credentials hidden.
+ */
+type LogLevel = 'debug' | 'error' | 'info' | 'off' | 'warn';
+//#endregion
+//#region src/internal/feature/retry.d.ts
+/** Which failed calls are sent again, how many times, and how long each waits first. */
+interface RetryOptions extends RetryRules {
+  /**
+   * How long to wait before the next attempt, in milliseconds, in place of the
+   * API's retry headers and the backoff. `undefined` keeps the usual wait.
+   * After a failure that got no reply, `result` holds only the `error`.
+   * **{@link maxRetryAfter} does not limit what this returns.**
+   */
+  retryDelay?(result: Result, request: PreparedRequest, attempt: number): number | undefined;
+  /**
+   * Whether to retry, in place of `statuses`, `x-should-retry` and
+   * `retryOnTimeout`. After a reply, the body is unread: read it from
+   * `response.clone()`. After a failure that got no reply, `result` holds only
+   * the `error`. A call the API may have acted on is never asked about: a
+   * method outside `methods` is sent again only after 408, 425 or 429, or when
+   * the request never reached the API.
+   */
+  retryOn?(result: Result, request: PreparedRequest): boolean;
+}
+//#endregion
+//#region src/internal/feature/timeout.d.ts
+/**
+ * Chooses the limit of one call, given the operation as `METHOD /path` and the
+ * limit it would otherwise get. `undefined` keeps that limit.
+ */
+type TimeoutPolicy = (operation: string, timeout: CallTimeout) => CallTimeout | undefined;
+/** A limit in milliseconds, `false` for none, or a policy choosing one per call. */
+type TimeoutValue = CallTimeout | TimeoutPolicy;
+//#endregion
+//#region src/internal/page/page.d.ts
+/**
+ * One page of a paginated call. Iterating a page walks from it to the end of
+ * the collection.
+ */
+interface Page<TItem = unknown, TBody = unknown> extends AsyncIterable<TItem> {
+  /** The whole reply body, counts and all. */
+  readonly body: TBody;
+  /** The items on this page. */
+  readonly data: ReadonlyArray<TItem>;
+  /** The next page. Throws if `hasNextPage()` is `false`. */
+  getNextPage(): Promise<Page<TItem, TBody>>;
+  /** Whether a page follows this one. It sends no request. */
+  hasNextPage(): boolean;
+  /**
+   * Where the page after this one begins, or `undefined` when none follows.
+   * Pass it back as `pageParam` to resume from here.
+   */
+  readonly nextPageParam: unknown;
+  /** The HTTP status of the reply that carried this page. */
+  readonly status: number;
+}
+/**
+ * A paginated call. Awaiting it gives the first page, or its result envelope
+ * under the `'return'` error mode. Iterating it gives every item on every page,
+ * and throws on a failed page under either mode.
+ */
+declare class PagePromise<TItem = unknown, TBody = unknown, TErrors = unknown, TAwaited = Page<TItem, TBody>, TMode extends ErrorMode = 'throw'> extends LazyPromise<PageResult<TAwaited, TErrors, TMode>> implements AsyncIterable<TItem> {
+  private envelope;
+  private readonly callable;
+  private readonly client;
+  private readonly limit;
+  private readonly maxPages;
+  private readonly options;
+  private readonly pagination;
+  private readonly project;
+  private readonly first;
+  constructor(client: Client, callable: CallableDescriptor, options: ResolvedOptions, project: (page: Page<TItem, TBody>) => TAwaited);
+  /** Every item, page after page, up to `maxPages`. */
+  [Symbol.asyncIterator](): AsyncGenerator<TItem>;
+  /** Every page, up to `maxPages`. */
+  iterPages(): AsyncIterable<Page<TItem, TBody>>;
+  /**
+   * The whole result envelope. A failure of the call is returned on it, not
+   * thrown. What one of your own functions throws, such as a hook, is thrown
+   * as it is.
+   */
+  result(): Promise<PageEnvelope<TAwaited, TErrors>>;
+  /** The page alone, with a failure thrown rather than handed back. */
+  unwrap(): Promise<TAwaited>;
+  private read;
+  protected settle(): Promise<PageResult<TAwaited, TErrors, TMode>>;
+}
+//#endregion
+//#region src/internal/transport/fetch.d.ts
+/** A `fetch` function, called with the full address and a built `RequestInit`. */
+type Fetch = (input: string, init: RequestInit) => Promise<Response>;
+/** What `fetch` takes, less what the client sets itself. */
+interface FetchOptions extends RequestInit {
+  /** Set by the client. */
+  body?: never;
+  /** Set by the client. Pass `headers` to the call. */
+  headers?: never;
+  /** Set by the client. */
+  method?: never;
+  /** Set by the client. Pass `signal` to the call. */
+  signal?: never;
+}
+//#endregion
+//#region src/resources/shared/resource.d.ts
+declare class ElmoResource {
+  /** The client every call on this SDK dispatches through. */
+  readonly client: Client;
+  constructor(client: Client);
+  /**
+   * The same calls, with different options.
+   *
+   * Options given here layer over the ones already in force. Headers, path
+   * parameters and query parameters merge per name. Everything else replaces.
+   * What this was called on does not change.
+   */
+  withOptions(options: ClientOptions): this;
+}
+//#endregion
+//#region src/resources/analytics.d.ts
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+declare class Analytics extends ElmoResource {
+  /**
+   * 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.
+   *
+   * @param brandId Brand identifier.
+   */
+  get(brandId: BrandIdPath, params: GetBrandAnalyticsParams, options?: RequestOptions): RestCallPromise<GetBrandAnalyticsResponses, GetBrandAnalyticsErrors>;
+}
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+declare class Domains extends ElmoResource {
+  /**
+   * 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.
+   *
+   * @param brandId Brand identifier.
+   */
+  list(brandId: BrandIdPath, params: ListBrandCitationDomainsParams, options?: RequestOptions): RestCallPromise<ListBrandCitationDomainsResponses, ListBrandCitationDomainsErrors>;
+}
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+declare class URLs extends ElmoResource {
+  /**
+   * List cited URLs
+   *
+   * Individual pages the engines cited, with their category and page type.
+   *
+   * @param brandId Brand identifier.
+   */
+  list(brandId: BrandIdPath, params: ListBrandCitationURLsParams, options?: RequestOptions): RestCallPromise<ListBrandCitationURLsResponses, ListBrandCitationURLsErrors>;
+}
+declare class Citations extends ElmoResource {
+  private _domains?;
+  /** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+  get domains(): Domains;
+  private _urls?;
+  /** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+  get urls(): URLs;
+}
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+declare class PromptPerformance extends ElmoResource {
+  /**
+   * 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.
+   *
+   * @param brandId Brand identifier.
+   */
+  list(brandId: BrandIdPath, params: ListBrandPromptPerformanceParams, options?: RequestOptions): RestCallPromise<ListBrandPromptPerformanceResponses, ListBrandPromptPerformanceErrors>;
+}
+/** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+declare class QueryFanout extends ElmoResource {
+  /**
+   * 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.
+   *
+   * @param brandId Brand identifier.
+   */
+  get(brandId: BrandIdPath, params: GetBrandQueryFanoutParams, options?: RequestOptions): RestCallPromise<GetBrandQueryFanoutResponses, GetBrandQueryFanoutErrors>;
+}
+declare namespace Analytics {
+  export type { BrandAnalytics, GetBrandAnalyticsErrors, GetBrandAnalyticsParams, GetBrandAnalyticsResponses, ModelVisibility, ShareOfVoiceEntry, ShareOfVoicePoint, VisibilityPoint };
+}
+declare namespace Domains {
+  export type { CitationDomain, CitationDomainList, ListBrandCitationDomainsErrors, ListBrandCitationDomainsParams, ListBrandCitationDomainsResponses };
+}
+declare namespace URLs {
+  export type { CitationURL, CitationURLList, ListBrandCitationURLsErrors, ListBrandCitationURLsParams, ListBrandCitationURLsResponses };
+}
+declare namespace Citations {
+  export type { CitationDomain, CitationDomainList, CitationURL, CitationURLList, Domains, ListBrandCitationDomainsErrors, ListBrandCitationDomainsParams, ListBrandCitationDomainsResponses, ListBrandCitationURLsErrors, ListBrandCitationURLsParams, ListBrandCitationURLsResponses, URLs };
+}
+declare namespace PromptPerformance {
+  export type { ListBrandPromptPerformanceErrors, ListBrandPromptPerformanceParams, ListBrandPromptPerformanceResponses, PromptPerformance$1 as PromptPerformance, PromptPerformanceList };
+}
+declare namespace QueryFanout {
+  export type { BrandQueryFanout, FanoutQuery, GetBrandQueryFanoutErrors, GetBrandQueryFanoutParams, GetBrandQueryFanoutResponses };
+}
+//#endregion
+//#region src/resources/opportunities.d.ts
+/** Where a brand could win more citations, and why */
+declare class Opportunities extends ElmoResource {
+  /**
+   * 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
+   * @param brandId Brand identifier.
+   */
+  get(brandId: BrandIdPath, options?: RequestOptions): RestCallPromise<GetBrandOpportunitiesResponses, GetBrandOpportunitiesErrors>;
+}
+declare namespace Opportunities {
+  export type { BrandOpportunities, CitedPage, GetBrandOpportunitiesErrors, GetBrandOpportunitiesResponses, Opportunity, OpportunityPrompt };
+}
+//#endregion
+//#region src/resources/tags.d.ts
+/** The tags in use on a brand's prompts */
+declare class Tags extends ElmoResource {
+  /**
+   * 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.
+   *
+   * @param brandId Brand identifier.
+   */
+  list(brandId: BrandIdPath, options?: RequestOptions): RestCallPromise<ListBrandTagsResponses, ListBrandTagsErrors>;
+}
+declare namespace Tags {
+  export type { ListBrandTagsErrors, ListBrandTagsResponses, Tag, TagList };
+}
+//#endregion
+//#region src/resources/brands.d.ts
+/** Manage brand records */
+declare class Brands extends ElmoResource {
+  /** Create a brand */
+  create(params: CreateBrandParams, options?: RequestOptions): RestCallPromise<CreateBrandResponses, CreateBrandErrors>;
+  /**
+   * Get a brand
+   *
+   * @param brandId Brand identifier
+   */
+  get(brandId: string, options?: RequestOptions): RestCallPromise<GetBrandResponses, GetBrandErrors>;
+  list(params?: ListBrandsParams, options?: RequestOptions): PagePromise<Brand, BrandsList, ListBrandsErrors>;
+  /**
+   * Update a brand
+   *
+   * @param brandId Brand identifier
+   */
+  update(brandId: string, params: UpdateBrandParams, options?: RequestOptions): RestCallPromise<UpdateBrandResponses, UpdateBrandErrors>;
+  private _analytics?;
+  /** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+  get analytics(): Analytics;
+  private _citations?;
+  get citations(): Citations;
+  private _opportunities?;
+  /** Where a brand could win more citations, and why */
+  get opportunities(): Opportunities;
+  private _promptPerformance?;
+  /** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+  get promptPerformance(): PromptPerformance;
+  private _queryFanout?;
+  /** Aggregated visibility, share of voice, citations, and query fan-out for a brand */
+  get queryFanout(): QueryFanout;
+  private _tags?;
+  /** The tags in use on a brand's prompts */
+  get tags(): Tags;
+}
+declare namespace Brands {
+  export type { Analytics, Brand, BrandAnalytics, BrandIdPath, BrandOpportunities, BrandQueryFanout, BrandsList, Citations, CitedPage, CreateBrandErrors, CreateBrandParams, CreateBrandResponses, DateRange, FanoutQuery, GetBrandAnalyticsErrors, GetBrandAnalyticsParams, GetBrandAnalyticsResponses, GetBrandErrors, GetBrandOpportunitiesErrors, GetBrandOpportunitiesResponses, GetBrandQueryFanoutErrors, GetBrandQueryFanoutParams, GetBrandQueryFanoutResponses, GetBrandResponses, ListBrandPromptPerformanceErrors, ListBrandPromptPerformanceParams, ListBrandPromptPerformanceResponses, ListBrandsErrors, ListBrandsParams, ListBrandsResponses, ListBrandTagsErrors, ListBrandTagsResponses, ModelVisibility, Opportunities, Opportunity, OpportunityPrompt, PromptPerformance, PromptPerformanceList, QueryFanout, ShareOfVoiceEntry, ShareOfVoicePoint, Tag, TagList, Tags, TagsFilter, UpdateBrandErrors, UpdateBrandParams, UpdateBrandResponses, VisibilityPoint };
+}
+//#endregion
+//#region src/resources/competitors.d.ts
+/** Manage brand competitors */
+declare class Competitors extends ElmoResource {
+  /** Add a competitor */
+  create(params: CreateCompetitorParams, options?: RequestOptions): RestCallPromise<CreateCompetitorResponses, CreateCompetitorErrors>;
+  /**
+   * Delete a competitor
+   *
+   * @param competitorId Competitor identifier (UUID)
+   */
+  delete(competitorId: string, options?: RequestOptions): RestCallPromise<DeleteCompetitorResponses, DeleteCompetitorErrors>;
+  /**
+   * Get a competitor
+   *
+   * @param competitorId Competitor identifier (UUID)
+   */
+  get(competitorId: string, options?: RequestOptions): RestCallPromise<GetCompetitorResponses, GetCompetitorErrors>;
+  list(params?: ListCompetitorsParams, options?: RequestOptions): PagePromise<Competitor, CompetitorsList, ListCompetitorsErrors>;
+  /**
+   * Update a competitor
+   *
+   * @param competitorId Competitor identifier (UUID)
+   */
+  update(competitorId: string, params: UpdateCompetitorParams, options?: RequestOptions): RestCallPromise<UpdateCompetitorResponses, UpdateCompetitorErrors>;
+}
+declare namespace Competitors {
+  export type { Competitor, CompetitorsList, CreateCompetitorErrors, CreateCompetitorParams, CreateCompetitorResponses, DeleteCompetitorErrors, DeleteCompetitorResponses, GetCompetitorErrors, GetCompetitorResponses, ListCompetitorsErrors, ListCompetitorsParams, ListCompetitorsResponses, UpdateCompetitorErrors, UpdateCompetitorParams, UpdateCompetitorResponses };
+}
+//#endregion
+//#region src/resources/identity.d.ts
+/** What the calling key is and what it may reach */
+declare class Me extends ElmoResource {
+  /**
+   * 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.
+   */
+  get(options?: RequestOptions): RestCallPromise<GetMeResponses, GetMeErrors>;
+}
+declare namespace Me {
+  export type { APIKeyIdentity, GetMeErrors, GetMeResponses };
+}
+//#endregion
+//#region src/resources/models.d.ts
+/** The answer engines this deployment can track */
+declare class Models extends ElmoResource {
+  /**
+   * 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.
+   */
+  list(options?: RequestOptions): RestCallPromise<ListModelsResponses, ListModelsErrors>;
+}
+declare namespace Models {
+  export type { ListModelsErrors, ListModelsResponses, Model, ModelList };
+}
+//#endregion
+//#region src/resources/organizations.d.ts
+/** Organizations, their plan limits, and their usage */
+declare class Billing extends ElmoResource {
+  /**
+   * 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.
+   */
+  get(organizationId: string, options?: RequestOptions): RestCallPromise<GetOrganizationBillingResponses, GetOrganizationBillingErrors>;
+}
+/** Organizations, their plan limits, and their usage */
+declare class Organizations extends ElmoResource {
+  /**
+   * Get an organization
+   *
+   * No scope required. An organization outside the key's reach answers `404`, identically to one
+   * that does not exist.
+   */
+  get(organizationId: string, options?: RequestOptions): RestCallPromise<GetOrganizationResponses, GetOrganizationErrors>;
+  /**
+   * 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.
+   */
+  list(params?: ListOrganizationsParams, options?: RequestOptions): PagePromise<Organization, OrganizationList, ListOrganizationsErrors>;
+  private _billing?;
+  /** Organizations, their plan limits, and their usage */
+  get billing(): Billing;
+}
+declare namespace Billing {
+  export type { BillingPlan, GetOrganizationBillingErrors, GetOrganizationBillingResponses, OrganizationBilling, PlanLimits };
+}
+declare namespace Organizations {
+  export type { Billing, BillingPlan, GetOrganizationBillingErrors, GetOrganizationBillingResponses, GetOrganizationErrors, GetOrganizationResponses, ListOrganizationsErrors, ListOrganizationsParams, ListOrganizationsResponses, Organization, OrganizationBilling, OrganizationList, PlanLimits };
+}
+//#endregion
+//#region src/resources/runs.d.ts
+/** Individual model answers behind the aggregates */
+declare class Runs extends ElmoResource {
+  /**
+   * 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.
+   */
+  get(promptId: string, runId: string, options?: RequestOptions): RestCallPromise<GetRunResponses, GetRunErrors>;
+  /**
+   * 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 `prompts.runs.get()` for the answer itself.
+   */
+  list(promptId: string, params: ListPromptRunsParams, options?: RequestOptions): PagePromise<RunSummary, RunList, ListPromptRunsErrors>;
+}
+declare namespace Runs {
+  export type { GetRunErrors, GetRunResponses, ListPromptRunsErrors, ListPromptRunsParams, ListPromptRunsResponses, Run, RunCitation, RunList, RunSummary };
+}
+//#endregion
+//#region src/resources/snapshots.d.ts
+/** Aggregated analytics snapshots for prompts */
+declare class Snapshot extends ElmoResource {
+  /**
+   * 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.
+   *
+   * @param promptId The ID of the prompt
+   */
+  get(promptId: string, params: GetPromptSnapshotParams, options?: RequestOptions): RestCallPromise<GetPromptSnapshotResponses, GetPromptSnapshotErrors>;
+}
+declare namespace Snapshot {
+  export type { CitedURLEntry, GetPromptSnapshotErrors, GetPromptSnapshotParams, GetPromptSnapshotResponses, PromptSnapshot };
+}
+//#endregion
+//#region src/resources/prompts.d.ts
+/** Manage brand prompts */
+declare class Prompts extends ElmoResource {
+  /**
+   * Create a new prompt
+   *
+   * Create a new prompt for a brand. This will automatically schedule the prompt for execution.
+   */
+  create(params: CreatePromptParams, options?: RequestOptions): RestCallPromise<CreatePromptResponses, CreatePromptErrors>;
+  /**
+   * 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 `prompts.update()` and `enabled: false`, which keeps its
+   * history and frees the plan slot.
+   *
+   * @param promptId The ID of the prompt to delete
+   */
+  delete(promptId: string, options?: RequestOptions): RestCallPromise<DeletePromptResponses, DeletePromptErrors>;
+  /**
+   * Get a prompt
+   *
+   * Retrieve a specific prompt by ID
+   *
+   * @param promptId The ID of the prompt
+   */
+  get(promptId: string, options?: RequestOptions): RestCallPromise<GetPromptResponses, GetPromptErrors>;
+  /**
+   * List all prompts
+   *
+   * Retrieve a paginated list of all prompts across all brands
+   */
+  list(params?: ListPromptsParams, options?: RequestOptions): PagePromise<Prompt, ListPromptsResponse, ListPromptsErrors>;
+  /**
+   * Update a prompt
+   *
+   * Update a prompt's properties. Only provided fields will be updated. Toggling `enabled`
+   * schedules or unschedules the recurring run job.
+   *
+   * @param promptId The ID of the prompt to update
+   */
+  update(promptId: string, params: UpdatePromptParams, options?: RequestOptions): RestCallPromise<UpdatePromptResponses, UpdatePromptErrors>;
+  private _runs?;
+  /** Individual model answers behind the aggregates */
+  get runs(): Runs;
+  private _snapshot?;
+  /** Aggregated analytics snapshots for prompts */
+  get snapshot(): Snapshot;
+}
+declare namespace Prompts {
+  export type { CitedURLEntry, CreatePromptErrors, CreatePromptParams, CreatePromptResponses, DeletePromptErrors, DeletePromptResponse, DeletePromptResponses, GetPromptErrors, GetPromptResponses, GetPromptSnapshotErrors, GetPromptSnapshotParams, GetPromptSnapshotResponses, GetRunErrors, GetRunResponses, ListPromptRunsErrors, ListPromptRunsParams, ListPromptRunsResponses, ListPromptsErrors, ListPromptsParams, ListPromptsResponse, ListPromptsResponses, Prompt, PromptSnapshot, Run, RunCitation, RunList, Runs, RunSummary, Snapshot, UpdatePromptErrors, UpdatePromptParams, UpdatePromptResponses };
+}
+//#endregion
+//#region src/resources/reports.d.ts
+/** Generate and retrieve AI Share of Voice reports */
+declare class Reports extends ElmoResource {
+  /**
+   * 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`.
+   */
+  create(params: CreateReportParams, options?: RequestOptions): RestCallPromise<CreateReportResponses, CreateReportErrors>;
+  /**
+   * 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`.
+   *
+   * @param reportId The ID of the report
+   */
+  get(reportId: string, params?: GetReportParams, options?: RequestOptions): RestCallPromise<GetReportResponses, GetReportErrors>;
+  /**
+   * Retrieve a paginated list of all reports, ordered by creation date (newest first).
+   *
+   * Requires an instance admin key; organization keys receive `403`.
+   */
+  list(params?: ListReportsParams, options?: RequestOptions): PagePromise<ReportSummary, ListReportsResponse, ListReportsErrors>;
+}
+declare namespace Reports {
+  export type { CreateReportErrors, CreateReportParams, CreateReportResponse, CreateReportResponses, GetReportErrors, GetReportParams, GetReportResponse, GetReportResponses, ListReportsErrors, ListReportsParams, ListReportsResponse, ListReportsResponses, ReportPromptSnapshot, ReportSummary };
+}
+//#endregion
+//#region src/resources/tools.d.ts
+/** One-shot helpers (e.g. brand analysis) that don't persist anything */
+declare class Tools extends ElmoResource {
+  /**
+   * 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`.
+   */
+  analyze(params: AnalyzeBrandParams, options?: RequestOptions): RestCallPromise<AnalyzeBrandResponses, AnalyzeBrandErrors>;
+}
+declare namespace Tools {
+  export type { AnalyzeBrandErrors, AnalyzeBrandParams, AnalyzeBrandResponses, OnboardingSuggestion };
+}
+//#endregion
+//#region src/client.d.ts
+/** The version of this package. */
+declare const VERSION = "0.1.0";
+/** The address calls are sent to: a URL with its scheme. */
+type BaseURL = `${string}://${string}/api/v1` | (string & {});
+/**
+ * How this client sends calls. Set on the client, or on one call to
+ * override it there.
+ */
+type BehaviorOptions = {
+  /**
+   * Specify a custom `fetch` implementation.
+   *
+   * Defaults to the global `fetch`, read for each request.
+   */
+  fetch?: Fetch;
+  /**
+   * Additional `RequestInit` options passed to `fetch` calls.
+   *
+   * A call that sets this replaces the whole block the client set.
+   */
+  fetchOptions?: FetchOptions;
+  /**
+   * Run your own hooks around every call. Each is an array of functions, which
+   * may be async.
+   *
+   * `request` reads the request after the credentials are on it and before it is
+   * sent. `response` and `error` each return what the caller reads, so a hook
+   * that only observes returns what it was given.
+   */
+  interceptors?: Interceptors;
+  /**
+   * Set the log level. Raise it to see what each call sent and what came back.
+   * `'debug'` adds headers, with credentials hidden.
+   *
+   * Read from the `ELMO_LOG` environment variable when unset.
+   *
+   * @default 'off'
+   */
+  logLevel?: LogLevel;
+  /**
+   * Set the logger. Anything with `debug`, `error`, `info` and `warn` methods.
+   * Defaults to `globalThis.console`.
+   */
+  logger?: Logger;
+  /**
+   * The most pages one walk fetches before it stops. Stepping through
+   * `getNextPage()` by hand is not capped.
+   *
+   * @default 1000
+   */
+  maxPages?: number;
+  /**
+   * The maximum number of times a failed call is sent again.
+   *
+   * The same count as `retry.maxRetries`, which wins where both are set. It
+   * counts retries and nothing else: `retry` decides which failures are retried.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+  /**
+   * How a failed call is retried, or `false` to send it once.
+   *
+   * @default { maxRetries: 2 }
+   */
+  retry?: RetryOptions | boolean;
+  /**
+   * The maximum time one attempt may run.
+   *
+   * Set `false` or `0` for no limit, or a function that returns the limit of one
+   * call. It is given the operation as `METHOD /path` and the limit the call
+   * would otherwise get.
+   *
+   * @default 60_000
+   *
+   * @unit milliseconds
+   */
+  timeout?: TimeoutValue;
+  /**
+   * Send calls through a transport of your own, for an HTTP library
+   * this client does not use.
+   *
+   * To swap the `fetch` it calls, use `fetch` or `fetchOptions`.
+   */
+  transport?: Transport<string, 'unary'>;
+};
+/**
+ * The credentials this API takes, each under its own name.
+ *
+ * Given to the constructor, one is sent with every call. Given to a call,
+ * it is sent with that call alone.
+ */
+type ClientCredentials = {
+  /**
+   * An instance admin key from `ADMIN_API_KEYS`, or an organization key
+   * (`elmo_…`) issued from the dashboard.
+   *
+   * Read from the `ELMO_API_KEY` environment variable when unset.
+   */
+  apiKey?: CredentialValue;
+};
+/** The options particular to this API. */
+type ClientNarrowing = {
+  /**
+   * Override the base URL calls are sent to.
+   *
+   * Read from the `ELMO_BASE_URL` environment variable when unset.
+   *
+   * @default '/api/v1'
+   */
+  baseURL?: BaseURL;
+  /**
+   * Build the client in a browser, where every visitor to the page can read
+   * the credential it sends. Pass `true` only where the credential is meant
+   * to be public, or a proxy adds it.
+   */
+  dangerouslyAllowBrowser?: boolean;
+  /**
+   * Headers to send with every call.
+   *
+   * Merged per name with whatever a call sets, and `null` drops one.
+   */
+  defaultHeaders?: MetadataOptions['headers'];
+  /**
+   * Path parameters every call starts from.
+   *
+   * Merged per name with whatever a call sets.
+   */
+  defaultPath?: MetadataOptions['path'];
+  /**
+   * Query parameters to add to every call.
+   *
+   * Merged per name with whatever a call sets, and `null` drops one.
+   */
+  defaultQuery?: MetadataOptions['query'];
+};
+/** Everything a client can be built with, and the defaults every call starts from. */
+type ClientOptions = BehaviorOptions & BodySerializerOptions & ClientCredentials & ClientNarrowing & CredentialOptions;
+/**
+ * A client for this API. Options given here apply to every call made
+ * through it. Pass it to a call, or to an SDK, in place of the default one.
+ *
+ * @example
+ * const elmo = createElmoClient({ apiKey: '…' });
+ */
+declare function createElmoClient(options?: ClientOptions): Client;
+/**
+ * The Elmo API, as one object to call through.
+ *
+ * Pass `apiKey`, or set `ELMO_API_KEY` and pass nothing.
+ *
+ * Options given here apply to every call it makes.
+ *
+ * @example
+ * const elmo = new Elmo();
+ * await elmo.brands.list();
+ */
+declare class Elmo extends ElmoResource {
+  constructor(args?: (ClientOptions & {
+    client?: never;
+  }) | {
+    /**
+     * A client to dispatch through, in place of one built from options.
+     *
+     * For sharing one configured client across several SDKs, or for
+     * one built with `createElmoClient`.
+     */
+    client: Client;
+  });
+  private _brands?;
+  /** Manage brand records */
+  get brands(): Brands;
+  private _competitors?;
+  /** Manage brand competitors */
+  get competitors(): Competitors;
+  private _me?;
+  /** What the calling key is and what it may reach */
+  get me(): Me;
+  private _models?;
+  /** The answer engines this deployment can track */
+  get models(): Models;
+  private _organizations?;
+  /** Organizations, their plan limits, and their usage */
+  get organizations(): Organizations;
+  private _prompts?;
+  /** Manage brand prompts */
+  get prompts(): Prompts;
+  private _reports?;
+  /** Generate and retrieve AI Share of Voice reports */
+  get reports(): Reports;
+  private _tools?;
+  /** One-shot helpers (e.g. brand analysis) that don't persist anything */
+  get tools(): Tools;
+  /** A failure the API answered with, so there is a status and a reply to read. */
+  static APIError: typeof APIError;
+  /**
+   * Thrown when the caller called the request off before the API answered.
+   *
+   * Not a {@link TransportError}, so code that retries or reports a failed
+   * connection leaves a call the caller cancelled alone.
+   */
+  static AbortError: typeof AbortError;
+  /** No usable credential reached the API: it was missing, unreadable, or rejected. */
+  static AuthenticationError: typeof AuthenticationError;
+  /** The API could not read the request, so it did not act on it. */
+  static BadRequestError: typeof BadRequestError;
+  /** The call collided with the resource's current state: a duplicate, or a concurrent change. */
+  static ConflictError: typeof ConflictError;
+  /** A reply from the API that this SDK could not read, whatever its status. */
+  static DecodeError: typeof DecodeError;
+  /** The base of every error this SDK throws, including one from a call that never arrived. */
+  static ElmoError: typeof ElmoError;
+  /** The API failed after accepting the call. Every status from 500 up arrives as this. */
+  static InternalServerError: typeof InternalServerError;
+  /** Thrown before the request goes out, when no credential satisfied the call. */
+  static MissingCredentialError: typeof MissingCredentialError;
+  /** Nothing is at this address, or the credential may not see what is. */
+  static NotFoundError: typeof NotFoundError;
+  /** The plan or the quota on this account does not cover the call. */
+  static PaymentRequiredError: typeof PaymentRequiredError;
+  /** The credential was accepted, but it does not grant this call. */
+  static PermissionDeniedError: typeof PermissionDeniedError;
+  /** Too many calls. {@link APIError.retryAfterMs} carries how long the API asked to wait. */
+  static RateLimitError: typeof RateLimitError;
+  /**
+   * Thrown when a call waited on the API for as long as it allowed, from sending
+   * the request to the last byte of the reply.
+   *
+   * A reply with status 408 is an {@link APIError}, not one of these.
+   */
+  static TimeoutError: typeof TimeoutError;
+  /** Thrown when no whole answer arrived, so there is no reply to go on. */
+  static TransportError: typeof TransportError;
+  /** The request was read, and its contents were rejected. */
+  static UnprocessableEntityError: typeof UnprocessableEntityError;
+}
+declare namespace Elmo {
+  export type { AnalyzeBrandErrors, AnalyzeBrandParams, AnalyzeBrandResponses, APIKeyIdentity, AuthResolver, AuthScheme, AuthToken, AuthValue, BackoffOptions, BaseURL, BodyInput, BodyPayload, Brand, BrandIdPath, Brands, BrandsList, CallResult, CallTimeout, Client, ClientOptions, Competitor, Competitors, CompetitorsList, ConflictError$1 as ConflictErrorResponse, CreateBrandErrors, CreateBrandParams, CreateBrandResponses, CreateCompetitorErrors, CreateCompetitorParams, CreateCompetitorResponses, CreatePromptErrors, CreatePromptParams, CreatePromptResponses, CreateReportErrors, CreateReportParams, CreateReportResponse, CreateReportResponses, CredentialValue, DateRange, DeleteCompetitorErrors, DeleteCompetitorResponses, DeletePromptErrors, DeletePromptResponse, DeletePromptResponses, Error$1 as Error, FailureBody, Fetch, FetchOptions, ForbiddenError, GetBrandErrors, GetBrandResponses, GetCompetitorErrors, GetCompetitorResponses, GetMeErrors, GetMeResponses, GetOrganizationErrors, GetOrganizationResponses, GetPromptErrors, GetPromptResponses, GetReportErrors, GetReportParams, GetReportResponse, GetReportResponses, Interceptors, InternalServerError$1 as InternalServerErrorResponse, Jitter, Limit, ListBrandsErrors, ListBrandsParams, ListBrandsResponses, ListCompetitorsErrors, ListCompetitorsParams, ListCompetitorsResponses, ListModelsErrors, ListModelsResponses, ListOrganizationsErrors, ListOrganizationsParams, ListOrganizationsResponses, ListPromptsErrors, ListPromptsParams, ListPromptsResponse, ListPromptsResponses, ListReportsErrors, ListReportsParams, ListReportsResponse, ListReportsResponses, LogFn, Logger, LogLevel, Me, MentionEntry, MentionsSummary, MetadataInput, MetadataOptions, Model, ModelFilter, ModelList, Models, NotFoundError$1 as NotFoundErrorResponse, OnboardingSuggestion, Organization, OrganizationList, Organizations, Page, PageEnvelope, Page$1 as PageParameter, PagePromise, PageResult, Pagination, PaymentRequiredError$1 as PaymentRequiredErrorResponse, PreparedRequest, Prompt, Prompts, RateLimitError$1 as RateLimitErrorResponse, ReportPromptSnapshot, Reports, ReportSummary, RequestOptions, RestCallPromise, Result, ResultEnvelope, RetryAfterHeader, RetryOptions, RetryRules, TagsFilter, TimeoutPolicy, TimeoutValue, Tools, Transport, TransportErrorKind, TransportFailure, TransportInteraction, UnauthorizedError, UpdateBrandErrors, UpdateBrandParams, UpdateBrandResponses, UpdateCompetitorErrors, UpdateCompetitorParams, UpdateCompetitorResponses, UpdatePromptErrors, UpdatePromptParams, UpdatePromptResponses, ValidationError, WindowEnd, WindowStart, WithResponse };
+}
+//#endregion
+//#region src/resources/shared/request-options.d.ts
+/** What one call may set for itself, overriding the client it goes through. */
+type RequestOptions = BehaviorOptions & BodySerializerOptions & ClientCredentials & ConnectionOptions<BaseURL, AuthValue, never> & MetadataOptions & PageOptions & SignalOptions & {
+  /**
+   * The client that sends this call, in place of the one this SDK uses.
+   *
+   * Build one with `createElmoClient`.
+   */
+  client?: Client;
+};
+//#endregion
+export { TransportError as C, TimeoutError as S, APIError as _, PagePromise as a, ElmoError as b, ConflictError as c, PaymentRequiredError as d, PermissionDeniedError as f, Client as g, RestCallPromise as h, createElmoClient as i, InternalServerError as l, UnprocessableEntityError as m, Elmo as n, AuthenticationError as o, RateLimitError as p, VERSION as r, BadRequestError as s, RequestOptions as t, NotFoundError as u, AbortError as v, MissingCredentialError as x, DecodeError as y };
+//# sourceMappingURL=request-options-DWYI_Ldj.d.mts.map