@allisall/sdk 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+@allisall/sdk
+Copyright 2026 All is AI

package/README.md

@@ -1,3 +1,90 @@
-# Temporary Holding Version
+# @allisall/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The allisall SDK for TypeScript and JavaScript. Version 0.1 sends events to
+the allisall API. It runs on Node 22 and later, and in current browsers.
+
+## Install
+
+```sh
+npm install @allisall/sdk
+```
+
+## Create a client
+
+The client reads your API key from `AIA_API_KEY`:
+
+```sh
+export AIA_API_KEY=aia_...
+```
+
+```ts
+import { Allisall } from "@allisall/sdk";
+
+const client = new Allisall();
+```
+
+You can also pass the key yourself, as `new Allisall({ apiKey })`. Create
+one client and reuse it.
+
+## Ingest events
+
+```ts
+import { Allisall, decimal } from "@allisall/sdk";
+
+const client = new Allisall();
+
+const summary = await client.events.ingest([
+  {
+    timestamp: new Date(),
+    agent_key: "support-bot",
+    category: "model",
+    event_type: "completion",
+    model: "gpt-4o",
+    tokens_in: 1200,
+    tokens_out: 300,
+    cost: decimal("0.0042"),
+  },
+]);
+
+console.log(summary.accepted, summary.duplicates, summary.rejected);
+```
+
+`ingest` takes any number of events. It sends them in batches, retries a
+failure worth retrying, and returns one summary for the whole list. A
+rejected event is listed in `summary.errors`, and the others are still
+stored. Write `cost` with `decimal()` to keep it exact.
+
+### Set your own `event_id` for at-least-once delivery
+
+The SDK gives every event without an `event_id` a new one. That makes a
+retry within one call safe, but it does not catch the same event sent
+again in a later call. If your events can be delivered more than once,
+for example from a queue that redelivers messages, set `event_id`
+yourself, such as to the message's id. The API then stores the event
+once, however often it arrives.
+
+## Browsers
+
+An API key in a browser can be read by anyone who loads the page. The
+client therefore refuses an API key in a browser unless you pass
+`dangerouslyAllowBrowser: true`:
+
+```ts
+import { Allisall } from "@allisall/sdk";
+
+// Only if you accept that anyone who loads the page can read this key.
+const client = new Allisall({
+  apiKey: "aia_...",
+  dangerouslyAllowBrowser: true,
+});
+```
+
+Prefer calling the API from your server.
+
+## Documentation
+
+See [https://docs.allisai.ai](https://docs.allisai.ai).
+
+## License
+
+Apache-2.0. See `LICENSE` and `NOTICE`.

package/dist/client.d.ts

@@ -0,0 +1,77 @@
+import { type FetchLike, type TokenProvider, type TransportConfig } from "./transport.js";
+import type { EventInput, IngestSummary } from "./types.js";
+/** The options of `new Allisall()`. Every one is optional. */
+export interface ClientOptions {
+    /**
+     * The API key. Defaults to `AIA_API_KEY` from the environment. Pass
+     * either this or `tokenProvider`, not both.
+     */
+    apiKey?: string | undefined;
+    /**
+     * A callback returning the bearer token to send, called before every
+     * attempt, retries included. Use it to supply an API key fetched at run
+     * time, for example from a secret store.
+     */
+    tokenProvider?: TokenProvider | undefined;
+    /**
+     * The API's base URL, absolute, `http` or `https`. Defaults to
+     * `AIA_BASE_URL` from the environment, then `https://api.allisai.ai`.
+     */
+    baseURL?: string | undefined;
+    /** The timeout of each attempt, in milliseconds. Defaults to 60,000. */
+    timeout?: number | undefined;
+    /** How many times a failure worth repeating is retried. Defaults to 2; 0 turns retries off. */
+    maxRetries?: number | undefined;
+    /** The `fetch` to send requests with. Defaults to the platform's own. */
+    fetch?: FetchLike | undefined;
+    /**
+     * Allows an API key in a browser, where anyone who loads the page can
+     * read it. Defaults to `false`.
+     */
+    dangerouslyAllowBrowser?: boolean | undefined;
+}
+/** The options of one call. */
+export interface RequestOptions {
+    /** Cancels the call, including any wait between retries. */
+    signal?: AbortSignal | undefined;
+}
+/** The `events` operations. */
+declare class Events {
+    #private;
+    constructor(config: TransportConfig);
+    /**
+     * Ingests any number of events. They are sent in batches of at most 500
+     * events and 5,000,000 bytes, one batch after another, each retried as
+     * the client allows. Every event without an `event_id` gets a generated
+     * one, so a retry never stores an event twice. Your objects are not
+     * modified.
+     *
+     * An event too large to send even alone is not sent, and is reported as a
+     * rejected row with the code `too_large`.
+     *
+     * @returns the combined outcome over the whole list.
+     * @throws {IngestError} when a batch fails; the call stops there, and the
+     * error carries the summary so far and every event from the failed batch
+     * onward, to send again. A batch fails on an error response, on no
+     * response, on the caller's cancellation, or when its token cannot be
+     * had: an error from `tokenProvider`, or, in a browser without
+     * `dangerouslyAllowBrowser`, a provider's token that is an API key. The
+     * error is the `IngestError`'s `cause`.
+     * @throws {TypeError} when an event cannot be encoded, before anything is sent.
+     */
+    ingest(events: readonly EventInput[], options?: RequestOptions): Promise<IngestSummary>;
+}
+/** The allisall API client. Construct one and reuse it. */
+export declare class Allisall {
+    /** The `events` operations. */
+    readonly events: Events;
+    /**
+     * @throws {AllisallError} when there is no credential, or both an API key
+     * and a token provider; when the base URL is not an absolute `http` or
+     * `https` URL; when `maxRetries` is negative or `timeout` is not
+     * positive; or when an API key is used in a browser without
+     * `dangerouslyAllowBrowser`.
+     */
+    constructor(options?: ClientOptions);
+}
+export {};

package/dist/client.js

@@ -0,0 +1,130 @@
+// The client: its options, and how the credential and the base URL are
+// resolved at construction.
+import { AllisallError } from "./errors.js";
+import { ingest, readIngestResult } from "./ingest.js";
+import { isBrowser, readEnv, userAgent } from "./runtime.js";
+import { BROWSER_KEY_MESSAGE, isPrintableCredential, post, } from "./transport.js";
+const DEFAULT_BASE_URL = "https://api.allisai.ai";
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_RETRIES = 2;
+function resolveCredential(options) {
+    const { apiKey, tokenProvider } = options;
+    if (apiKey !== undefined && tokenProvider !== undefined) {
+        throw new AllisallError("allisall: pass either apiKey or tokenProvider, not both");
+    }
+    if (tokenProvider !== undefined) {
+        if (typeof tokenProvider !== "function") {
+            throw new AllisallError("allisall: tokenProvider must be a function");
+        }
+        return { kind: "provider", provider: tokenProvider };
+    }
+    if (apiKey !== undefined) {
+        const key = typeof apiKey === "string" ? apiKey.trim() : "";
+        if (key === "") {
+            throw new AllisallError("allisall: apiKey is empty");
+        }
+        if (!isPrintableCredential(key)) {
+            throw new AllisallError("allisall: apiKey holds a character other than printable ASCII, which cannot be sent");
+        }
+        return { kind: "apiKey", apiKey: key };
+    }
+    // A variable of white space alone counts as unset.
+    const fromEnv = readEnv("AIA_API_KEY")?.trim();
+    if (fromEnv !== undefined && fromEnv !== "") {
+        if (!isPrintableCredential(fromEnv)) {
+            throw new AllisallError("allisall: AIA_API_KEY holds a character other than printable ASCII, which cannot be sent");
+        }
+        return { kind: "apiKey", apiKey: fromEnv };
+    }
+    throw new AllisallError("allisall: no credential; pass apiKey or tokenProvider, or set AIA_API_KEY");
+}
+function resolveBaseURL(option) {
+    const raw = option ?? readEnv("AIA_BASE_URL") ?? DEFAULT_BASE_URL;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new AllisallError(`allisall: the base URL ${JSON.stringify(raw)} is not an absolute URL`);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new AllisallError(`allisall: the base URL ${JSON.stringify(raw)} is not http or https`);
+    }
+    return url;
+}
+function resolveTimeout(option) {
+    const timeout = option ?? DEFAULT_TIMEOUT_MS;
+    if (typeof timeout !== "number" ||
+        !Number.isFinite(timeout) ||
+        timeout <= 0) {
+        throw new AllisallError(`allisall: timeout must be a positive number of milliseconds, not ${String(timeout)}`);
+    }
+    return timeout;
+}
+function resolveMaxRetries(option) {
+    const maxRetries = option ?? DEFAULT_MAX_RETRIES;
+    if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+        throw new AllisallError(`allisall: maxRetries must be a whole number, 0 or more, not ${String(maxRetries)}`);
+    }
+    return maxRetries;
+}
+/** The `events` operations. */
+class Events {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * Ingests any number of events. They are sent in batches of at most 500
+     * events and 5,000,000 bytes, one batch after another, each retried as
+     * the client allows. Every event without an `event_id` gets a generated
+     * one, so a retry never stores an event twice. Your objects are not
+     * modified.
+     *
+     * An event too large to send even alone is not sent, and is reported as a
+     * rejected row with the code `too_large`.
+     *
+     * @returns the combined outcome over the whole list.
+     * @throws {IngestError} when a batch fails; the call stops there, and the
+     * error carries the summary so far and every event from the failed batch
+     * onward, to send again. A batch fails on an error response, on no
+     * response, on the caller's cancellation, or when its token cannot be
+     * had: an error from `tokenProvider`, or, in a browser without
+     * `dangerouslyAllowBrowser`, a provider's token that is an API key. The
+     * error is the `IngestError`'s `cause`.
+     * @throws {TypeError} when an event cannot be encoded, before anything is sent.
+     */
+    ingest(events, options = {}) {
+        const config = this.#config;
+        return ingest(events, (body, count, signal) => post(config, "/v1/events", body, (value) => readIngestResult(value, count), signal), options.signal);
+    }
+}
+/** The allisall API client. Construct one and reuse it. */
+export class Allisall {
+    /** The `events` operations. */
+    events;
+    /**
+     * @throws {AllisallError} when there is no credential, or both an API key
+     * and a token provider; when the base URL is not an absolute `http` or
+     * `https` URL; when `maxRetries` is negative or `timeout` is not
+     * positive; or when an API key is used in a browser without
+     * `dangerouslyAllowBrowser`.
+     */
+    constructor(options = {}) {
+        const credential = resolveCredential(options);
+        const browser = isBrowser();
+        const refuseApiKeys = browser && options.dangerouslyAllowBrowser !== true;
+        if (refuseApiKeys && credential.kind === "apiKey") {
+            throw new AllisallError(BROWSER_KEY_MESSAGE);
+        }
+        this.events = new Events({
+            baseURL: resolveBaseURL(options.baseURL),
+            credential,
+            timeout: resolveTimeout(options.timeout),
+            maxRetries: resolveMaxRetries(options.maxRetries),
+            fetch: options.fetch,
+            refuseApiKeys,
+            userAgent: userAgent(),
+        });
+    }
+}

package/dist/decimal.d.ts

@@ -0,0 +1,20 @@
+declare const decimalBrand: unique symbol;
+/**
+ * An exact decimal amount, such as a `cost`. It is a string at run time,
+ * branded so that only `decimal()` produces one. The SDK writes its text
+ * into the request unchanged, as a JSON number, so no binary float ever
+ * rounds it.
+ */
+export type Decimal = string & {
+    readonly [decimalBrand]: true;
+};
+/** Reports whether `text` has the syntax of a `Decimal`. */
+export declare function isDecimalText(text: string): boolean;
+/**
+ * Makes a `Decimal` from its text, such as `decimal("0.3683")`.
+ *
+ * @throws {TypeError} when `text` is not an optional `-`, digits without a
+ * leading zero (or a single `0`), and optional decimal places after a `.`.
+ */
+export declare function decimal(text: string): Decimal;
+export {};

package/dist/decimal.js

@@ -0,0 +1,23 @@
+/**
+ * The syntax a `Decimal` accepts: an optional `-`, digits without a leading
+ * zero (or a single `0`), and optional decimal places after a `.`. Every
+ * string it accepts is a valid JSON number.
+ */
+const DECIMAL_SYNTAX = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/;
+/** Reports whether `text` has the syntax of a `Decimal`. */
+export function isDecimalText(text) {
+    return DECIMAL_SYNTAX.test(text);
+}
+/**
+ * Makes a `Decimal` from its text, such as `decimal("0.3683")`.
+ *
+ * @throws {TypeError} when `text` is not an optional `-`, digits without a
+ * leading zero (or a single `0`), and optional decimal places after a `.`.
+ */
+export function decimal(text) {
+    if (typeof text !== "string" || !isDecimalText(text)) {
+        throw new TypeError(`allisall: ${JSON.stringify(text)} is not a decimal; write it as digits with an optional "-" and decimal places, such as "12.5"`);
+    }
+    // The syntax check above is the invariant the brand stands for.
+    return text;
+}

package/dist/errors.d.ts

@@ -0,0 +1,79 @@
+import type { ErrorCode, EventInput, IngestSummary, Problem } from "./types.js";
+/**
+ * The base of every error the SDK throws. Catch it to handle any SDK
+ * failure; catch `ApiError`, `ConnectionError` or `IngestError` to handle
+ * one condition.
+ */
+export declare class AllisallError extends Error {
+    name: string;
+}
+/** The members of an `ApiError`. */
+export interface ApiErrorInit {
+    status: number;
+    problem?: Problem | undefined;
+    requestId?: string | undefined;
+    retryAfter?: number | undefined;
+    headers: Headers;
+    message?: string | undefined;
+}
+/**
+ * An error response from the API, or a successful response whose body was
+ * not the expected shape. Branch on `code`; for a code you do not
+ * recognise, fall back on `status`.
+ */
+export declare class ApiError extends AllisallError {
+    name: string;
+    /** The HTTP status. */
+    readonly status: number;
+    /** The problem's `code`. Absent when the body was not a problem document. */
+    readonly code: ErrorCode | undefined;
+    /** The whole problem document. Absent when the body was not one. */
+    readonly problem: Problem | undefined;
+    /** The problem's `request_id`, or else the response's `X-Request-Id`. */
+    readonly requestId: string | undefined;
+    /**
+     * The response's `Retry-After`, in milliseconds from when the response
+     * arrived. Absent when the response had none, or one that did not parse
+     * or named a time in the past.
+     */
+    readonly retryAfter: number | undefined;
+    /** The response headers. */
+    readonly headers: Headers;
+    constructor(init: ApiErrorInit);
+}
+/**
+ * A request that got no response: the connection failed, was reset, or the
+ * attempt timed out. `cause` holds the underlying error.
+ */
+export declare class ConnectionError extends AllisallError {
+    name: string;
+    /** The `X-Request-Id` the SDK sent on the last attempt, to quote when reporting it. */
+    readonly requestId: string;
+    constructor(requestId: string, cause: unknown);
+}
+/**
+ * A batch of an `ingest` call failed, so the call stopped and sent nothing
+ * after it. `cause` holds what failed the batch: an `ApiError`, a
+ * `ConnectionError`, the caller's cancellation, or the error from getting
+ * the token: the token provider's own error, unchanged, or the
+ * `AllisallError` refusing a provider's API key in a browser. To recover,
+ * send `remaining` again: every event in it keeps the `event_id` it was
+ * sent with, so any the failed batch stored come back as duplicates.
+ */
+export declare class IngestError extends AllisallError {
+    name: string;
+    /** The combined outcome of the batches that succeeded before the failed one. */
+    readonly summary: IngestSummary;
+    /**
+     * Copies of every event from the failed batch onward, each with its
+     * `event_id`, less any event too large to send: those are rows of
+     * `summary.errors` and never in `remaining`. To map `remaining` back to
+     * your list, walk it from `remainingFrom` and skip the `index` of every
+     * `summary.errors` row at or past `remainingFrom`. With no such row,
+     * `remaining[i]` is your event `remainingFrom + i`.
+     */
+    readonly remaining: EventInput[];
+    /** The index, in the list passed to `ingest`, of the first event in `remaining`. */
+    readonly remainingFrom: number;
+    constructor(cause: unknown, summary: IngestSummary, remaining: EventInput[], remainingFrom: number);
+}