@alexein/sdk 0.0.0-stage → 0.3.0

package/dist/client-YKZ4fkK-.d.ts

@@ -0,0 +1,641 @@
+/**
+ * Reading the API's JSON without trusting its shape: each reader answers a value of the type asked
+ * for, or the absent value, so a field the API leaves out or changes never throws while parsing.
+ */
+/** A JSON object, as the API sends it. */
+type Json = Record<string, unknown>;
+
+/**
+ * The memories search, grep, latest, around and open answer: known lines, facts and excerpts,
+ * told apart by `type`. Each keeps the JSON it was read from as `raw`.
+ */
+
+/** A line memory takes to be true now. */
+interface Known {
+    readonly type: "known";
+    readonly text: string;
+    readonly raw: Json;
+}
+/** Something learned from what was said, with its ref. */
+interface Fact {
+    readonly type: "fact";
+    /** Opens it with `user.open(ref)`; names it to `forget` and `correct`. */
+    readonly ref: string;
+    readonly text: string;
+    /** The ref of the excerpt it came from, or null. */
+    readonly source: string | null;
+    /** When it was said: on `facts()` only, null elsewhere. */
+    readonly date: string | null;
+    readonly raw: Json;
+}
+/** Part of what was said or delivered, with its ref. */
+interface Excerpt {
+    readonly type: "excerpt";
+    readonly ref: string;
+    readonly text: string;
+    /** When it happened, or null when unknown. */
+    readonly date: string | null;
+    /** When memory took it. */
+    readonly addedAt: string | null;
+    readonly session: string | null;
+    /** The roles of who spoke in it: `user`, `assistant`. */
+    readonly roles: string[];
+    readonly raw: Json;
+}
+/** One memory, of whichever type. */
+type MemoryEntry = Known | Fact | Excerpt;
+
+/** What the reads other than search answer: grep, latest, around, open, history, summary and more. */
+
+/**
+ * Memories in order, from grep (with `pattern` and `total`), latest (with `places` when a place
+ * matched nothing: the places there are) or around. Iterable.
+ */
+interface Memories extends Iterable<MemoryEntry> {
+    readonly memories: MemoryEntry[];
+    readonly pattern: string | null;
+    readonly total: number | null;
+    readonly places: string[] | null;
+    readonly raw: Json;
+}
+/** One memory whole: an excerpt, or a fact with the excerpts it was learned from. */
+interface Opened {
+    readonly memory: Fact | Excerpt;
+    readonly sources: Excerpt[];
+    readonly raw: Json;
+}
+/** One value a subject was stated to have, and since when. */
+interface Value {
+    readonly attribute: string;
+    readonly value: string;
+    readonly since: string | null;
+    /** True when it was stated not to hold. */
+    readonly negated: boolean;
+    readonly raw: Json;
+}
+/**
+ * Every value a subject was stated to have, by attribute, oldest first. `suggestions` names
+ * subjects close to one memory does not know, and is null otherwise.
+ */
+interface History {
+    readonly subject: string;
+    readonly values: Value[];
+    readonly suggestions: string[] | null;
+    readonly raw: Json;
+}
+/** What one connected app delivered through one connection. */
+interface Source {
+    readonly provider: string;
+    readonly source: string;
+    readonly connection: string;
+    /** How many items it delivered. */
+    readonly items: number;
+    /** How many of them ended. */
+    readonly ended: number;
+    /** When the newest happened. */
+    readonly newest: string | null;
+    readonly raw: Json;
+}
+/** What each connected app delivered to this memory. */
+interface Sources {
+    readonly sources: Source[];
+    readonly raw: Json;
+}
+/**
+ * This memory in brief: how many items, the span they cover, the connected sources, and the known
+ * lines - what memory takes to be true now.
+ */
+interface Summary {
+    readonly items: number;
+    readonly first: string | null;
+    readonly last: string | null;
+    readonly sources: Source[];
+    readonly known: string[];
+    readonly raw: Json;
+}
+/** An issue or pull request still open. */
+interface OpenItem {
+    readonly ref: string;
+    readonly text: string;
+    readonly date: string | null;
+    readonly addedAt: string | null;
+    readonly ageDays: number | null;
+    readonly raw: Json;
+}
+/** An open ask nobody answered. */
+interface FollowUp {
+    readonly title: string | null;
+    readonly who: string | null;
+    readonly date: string | null;
+    readonly ageDays: number | null;
+    readonly raw: Json;
+}
+interface OpenItems {
+    readonly items: OpenItem[];
+    readonly followUps: FollowUp[];
+    readonly raw: Json;
+}
+
+/**
+ * What `add` takes - a string, an item, or a list of either - shaped into the requests it sends:
+ * at most 500 items each, every one with an `Idempotency-Key` its retries send again.
+ */
+
+/** Who said it. `id` is your stable id for the person; `email` and `handle` join them up. */
+interface Author {
+    id?: string | null;
+    name?: string | null;
+    email?: string | null;
+    handle?: string | null;
+    /** True when it is the app user themself. */
+    self?: boolean | null;
+}
+/**
+ * One thing to remember. Only `text` is required. The same `id` again is an edit of it; set
+ * `expires` (an ISO date) for what stops being true, or `null` to lift an expiry.
+ */
+interface Item {
+    text: string;
+    kind?: "message" | "document" | "note";
+    id?: string | null;
+    session?: string | null;
+    role?: string | null;
+    author?: string | Author | null;
+    title?: string | null;
+    /** What it is about, as `kind:name`: `project:atlas`. */
+    about?: string[] | null;
+    /** When it happened: an ISO date or timestamp. */
+    at?: string | null;
+    expires?: string | null;
+    metadata?: Json | null;
+}
+/** The item fields `add` fills in for every item that does not set its own. */
+interface ItemDefaults {
+    kind?: Item["kind"];
+    session?: string;
+    role?: string;
+    author?: string | Author;
+    title?: string;
+    about?: string[];
+    expires?: string;
+    at?: string;
+    metadata?: Json;
+}
+/** Options `add` takes besides the items. */
+interface AddOptions extends ItemDefaults {
+    /** Answer once the items are searchable (briefly waited for). */
+    wait?: boolean;
+    /** Replace phone numbers, cards, keys and the like with their kind before memory keeps them. */
+    redact?: boolean;
+}
+type Adding = string | Item | readonly (string | Item)[];
+
+/**
+ * The paged answers - facts, items, export, users - and the items, app users and key they hold.
+ * `next` is the cursor of the page after, null on the last; the `iter*` methods follow it.
+ */
+
+interface FactsPage {
+    readonly facts: Fact[];
+    readonly next: string | null;
+    readonly raw: Json;
+}
+/** An item as `add` was given it, and whether it is searchable yet. */
+interface StoredItem {
+    readonly id: string;
+    readonly kind: string | null;
+    readonly text: string;
+    readonly title: string | null;
+    readonly at: string | null;
+    readonly author: string | Author | null;
+    readonly role: string | null;
+    readonly session: string | null;
+    readonly about: string[] | null;
+    readonly metadata: Json | null;
+    readonly expires: string | null;
+    /** `queued` while it waits to be stored, then `stored`. */
+    readonly status: string;
+    readonly raw: Json;
+}
+interface ItemsPage {
+    readonly items: StoredItem[];
+    readonly next: string | null;
+    readonly raw: Json;
+}
+/** An app user of the key's project with memory. */
+interface AppUser {
+    readonly user: string;
+    readonly items: number;
+    readonly facts: number;
+    /** When memory last took something for them; null when unknown. */
+    readonly lastWrite: string | null;
+    readonly raw: Json;
+}
+interface UsersPage {
+    readonly users: AppUser[];
+    readonly next: string | null;
+    readonly raw: Json;
+}
+/**
+ * One record of an export, as the API sent it: `type` is `item`, `version`, `event` or `fact`,
+ * and the rest of its fields are that record's own.
+ */
+type ExportRecord = Json & {
+    type: string;
+};
+/**
+ * A page of everything memory holds for an app user. `withheld` names what a read key went
+ * without (`version`).
+ */
+interface ExportPage {
+    readonly user: string;
+    readonly exportedAt: string | null;
+    readonly records: ExportRecord[];
+    readonly next: string | null;
+    readonly withheld: string[];
+    readonly raw: Json;
+}
+/** What the API key is. `kind` is `key` for an API key. */
+interface Me {
+    readonly kind: string;
+    readonly org: string | null;
+    readonly project: string | null;
+    readonly keyId: string | null;
+    /** Whether the key may add, forget and correct, or only read. */
+    readonly writes: boolean;
+    readonly label: string | null;
+    /** Who made the key: an email, or null when unknown. */
+    readonly createdBy: string | null;
+    readonly orgName: string | null;
+    readonly projectName: string | null;
+    /** `project` for a project's key, `personal` for a member's personal space. */
+    readonly space: string | null;
+    readonly raw: Json;
+}
+
+/** What `search` answers, and the text of it to paste into a prompt. */
+
+/**
+ * What memory holds for a question. `memories` come in order: known lines, then facts, then
+ * excerpts. `answerable` is false when memory does not seem to hold the answer, and null when it
+ * was not checked. `failed` is true when a `failOpen` client could not reach memory, and the
+ * result is empty for that reason.
+ */
+declare class SearchResult {
+    readonly query: string;
+    readonly answerable: boolean | null;
+    readonly notes: string[];
+    readonly memories: MemoryEntry[];
+    readonly sources: Json[] | null;
+    readonly failed: boolean;
+    readonly raw: Json;
+    constructor(query: string, answerable: boolean | null, notes: string[], memories: MemoryEntry[], sources: Json[] | null, failed: boolean, raw: Json);
+    static parse(value: unknown): SearchResult;
+    /** What a `failOpen` client answers when memory could not be reached. */
+    static unavailable(query: string): SearchResult;
+    get known(): Known[];
+    get facts(): Fact[];
+    get excerpts(): Excerpt[];
+    /** Every ref, in order: each opens with `user.open(ref)`. */
+    get refs(): string[];
+    /**
+     * The text to paste into a prompt: each note on its own line, a blank line, then each memory on
+     * its own line as `- <text>` (an excerpt with a date as `- <YYYY-MM-DD>: <text>`), cut at a whole
+     * memory so it is never longer than `maxChars`. Empty when there are no memories, or when not
+     * even the first fits. The Python client and the n8n node write the same text.
+     */
+    context(maxChars?: number): string;
+}
+
+/** The client's settings: from its options, else the environment, else the defaults. */
+declare const DEFAULT_BASE_URL = "https://api.alexein.ai";
+/** Long enough for the slowest search and an add that waits; a caller that cannot wait sets less. */
+declare const DEFAULT_TIMEOUT_MS = 60000;
+declare const DEFAULT_RETRIES = 2;
+interface MemoryOptions {
+    /** Defaults to `ALEXEIN_API_KEY` from the environment. */
+    apiKey?: string;
+    /** The API's host. Defaults to `ALEXEIN_API_URL`, else `https://api.alexein.ai`. */
+    baseUrl?: string;
+    /** Milliseconds one attempt may take: 60000 by default. */
+    timeout?: number;
+    /** How many more times a 429, a 503, a timeout or an unreached service is tried: 2. */
+    maxRetries?: number;
+    /**
+     * Ride out an outage - memory unreachable, timing out, or answering 429 or 5xx after its
+     * retries: `search` answers empty and `add` saves nothing, each with `failed: true` and a
+     * warning logged, instead of throwing. A wrong key or request still throws.
+     */
+    failOpen?: boolean;
+    /** A word added to the User-Agent, so the console's request logs show where calls came from. */
+    integration?: string;
+    /** Where warnings go: `console.warn` by default. */
+    logger?: (message: string) => void;
+    /** The `fetch` to send with: the global one by default. */
+    fetch?: typeof fetch;
+}
+interface Settings {
+    key: string;
+    baseUrl: string;
+    timeout: number;
+    maxRetries: number;
+    failOpen: boolean;
+    integration: string | null;
+    userAgent: string;
+    log: (message: string) => void;
+    fetch: typeof fetch;
+}
+
+/**
+ * Sending one request: its headers, a timeout per attempt, and retries - 429 and 503, a timeout
+ * or an unreached service - waiting as `Retry-After` says (at most 60 s) or with backoff.
+ */
+
+/** One request, described once: what it sends and how to read the answer. */
+interface Call<T> {
+    method: "GET" | "POST";
+    /** After `/v2`: `/memory/search`, `/me`. */
+    path: string;
+    body?: Json;
+    headers?: Record<string, string>;
+    parse: (body: unknown) => T;
+}
+declare class Transport {
+    private readonly settings;
+    constructor(settings: Settings);
+    /** Send `call` for app user `user` (none for `me` and `users`), retrying as the API asks. */
+    send<T>(call: Call<T>, user?: string): Promise<T>;
+    private attempt;
+    private answer;
+    private refusal;
+}
+
+/** What the writes answer, and the reads that say what became of them: add, status, versions. */
+
+/** One item of an add: `stored` (searchable) or `queued` (searchable in a moment). */
+interface AddedItem {
+    readonly id: string;
+    readonly status: string;
+    /** With `redact`: how many of each kind were replaced (`{PHONE: 1}`); null when none. */
+    readonly redacted: Record<string, number> | null;
+    readonly raw: Json;
+}
+/**
+ * An add's answer. `waiting` is how many items are not searchable yet; zero once they are.
+ * `failed` is true when a `failOpen` client could not reach memory, and nothing more was saved.
+ */
+interface AddResult {
+    readonly items: AddedItem[];
+    readonly waiting: number;
+    readonly failed: boolean;
+    /** Each item's id, in order. */
+    readonly ids: string[];
+    readonly raw: Json;
+}
+/** How far one item has got: `queued`, `stored`, `processed` or `unknown`. */
+interface ItemStatus {
+    readonly id: string;
+    readonly status: string;
+    /** Null unless something holds it back; then what does, in words. */
+    readonly reason: string | null;
+    readonly raw: Json;
+}
+interface Statuses {
+    readonly items: ItemStatus[];
+    /** Each id's status. */
+    readonly byId: Record<string, string>;
+    readonly raw: Json;
+}
+/**
+ * What a forget erased: the items, the facts learned from them, the versions an edit kept, the
+ * copies still on their way in; and `relearning`, the facts of other items that stay, taken to be
+ * learned again from what is left.
+ */
+interface Erased {
+    readonly items: number;
+    readonly facts: number;
+    readonly versions: number;
+    readonly waiting: number;
+    readonly relearning: number;
+}
+/** `complete` is false when some copies on their way in could not be checked: ask again. */
+interface Forgotten {
+    readonly erased: Erased;
+    readonly complete: boolean;
+    readonly raw: Json;
+}
+/** The fact retracted (its ref), its text, and the id of the note holding what is true instead. */
+interface Correction {
+    readonly retracted: string;
+    readonly text: string | null;
+    readonly replacement: string | null;
+    readonly raw: Json;
+}
+/**
+ * One line of an item's history: a `version` (`at`, its number and the item as it was held) or,
+ * once it went, `gone` (`at` and `why`: `forgotten` or `expired`).
+ */
+interface VersionEntry {
+    readonly event: string;
+    readonly at: string | null;
+    readonly version: number | null;
+    readonly item: Json | null;
+    readonly why: string | null;
+    readonly raw: Json;
+}
+/** Every version of one added item, oldest first. `state`: live, expired, forgotten or unknown. */
+interface Versions {
+    readonly id: string;
+    readonly state: string;
+    readonly history: VersionEntry[];
+    readonly raw: Json;
+}
+/** An app user erased whole. */
+interface Deleted {
+    readonly user: string;
+    readonly deleted: boolean;
+    readonly raw: Json;
+}
+
+/**
+ * Each route as the request it is: path, body and how to read the answer. Written once here and
+ * sent by the client; the same requests the Python client sends. Fields left unset are not sent.
+ */
+
+/**
+ * Only items that match: `author`, `mentions` (`kind:name`, or `session:<id>`) and `metadata`
+ * keys, as `{field: value}` or `{field: {op: value}}`, in `AND`, `OR` and `NOT`.
+ */
+type Filters = Json;
+/** Narrowing to what a connected app delivered. `kind` takes one kind or several. */
+interface Origin {
+    provider?: string;
+    source?: string;
+    kind?: string | string[];
+}
+interface SearchOptions extends Origin {
+    /** ISO date: the question is answered as of that day. */
+    before?: string;
+    /** ISO date: only memory from this day on; the answer is then the facts and excerpts that match. */
+    after?: string;
+    filters?: Filters;
+    /** Answer sooner, a little less precisely. Free. */
+    fast?: boolean;
+}
+interface GrepOptions extends Origin {
+    limit?: number;
+}
+interface LatestOptions extends Origin {
+    k?: number;
+    /** A connected app, a channel or a repository. */
+    place?: string;
+    after?: string;
+    before?: string;
+    filters?: Filters;
+}
+interface OpenItemsOptions {
+    kind?: string | string[];
+    provider?: string;
+    place?: string;
+    /** The person's own (the default), or everyone's. */
+    mine?: boolean;
+    /** Only those from the last this many days; 0 is any age. */
+    withinDays?: number;
+    limit?: number;
+}
+interface PageOptions {
+    limit?: number;
+    cursor?: string | null;
+}
+interface ItemsOptions extends PageOptions {
+    filters?: Filters;
+}
+interface ForgetOptions {
+    items?: string[];
+    sessions?: string[];
+    /** Refs of facts or excerpts. */
+    refs?: string[];
+}
+
+/** One app user's memory: every call sends their id as `X-Alexein-User`. */
+
+declare class User {
+    private readonly transport;
+    /** Your id for this app user. */
+    readonly id: string;
+    private readonly failOpen;
+    private readonly log;
+    /** @internal Made by `memory.user(id)`. */
+    constructor(transport: Transport, 
+    /** Your id for this app user. */
+    id: string, failOpen: boolean, log: (message: string) => void);
+    private send;
+    /**
+     * Remember text: a string, an item, or a list of either. The options fill in each item's unset
+     * fields. More than 500 items go as several requests; a retry never saves an item twice.
+     */
+    add(items: Adding, options?: AddOptions): Promise<AddResult>;
+    /** What memory holds for a question: known lines, facts and excerpts, in order. */
+    search(query: string, options?: SearchOptions): Promise<SearchResult>;
+    /** Excerpts holding an exact phrase, ignoring case. */
+    grep(pattern: string, options?: GrepOptions): Promise<Memories>;
+    /** The most recent excerpts, newest first; with `after` and `before`, everything between. */
+    latest(options?: LatestOptions): Promise<Memories>;
+    /** The excerpts just before and after one, from the same conversation, in order. */
+    around(ref: string, options?: {
+        width?: number;
+    }): Promise<Memories>;
+    /** One memory by its ref, whole: an excerpt, or a fact with the excerpts it came from. */
+    open(ref: string): Promise<Opened>;
+    /** Every value a subject was stated to have, by attribute, oldest first. */
+    history(subject: string, options?: {
+        attribute?: string;
+    }): Promise<History>;
+    /** This memory in brief: its items, their span, the connected sources and the known lines. */
+    summary(): Promise<Summary>;
+    /** The facts memory learned, newest first, a page at a time. */
+    facts(options?: PageOptions): Promise<FactsPage>;
+    /** Every fact, across pages. */
+    iterFacts(options?: {
+        limit?: number;
+    }): AsyncIterable<Fact>;
+    /** The issues and pull requests still open, and the asks nobody answered. */
+    openItems(options?: OpenItemsOptions): Promise<OpenItems>;
+    /** What each connected app delivered to this memory. */
+    sources(): Promise<Sources>;
+    /** The items added, newest first, as they were given, a page at a time. */
+    items(options?: ItemsOptions): Promise<ItemsPage>;
+    /** Every item, across pages. */
+    iterItems(options?: {
+        limit?: number;
+        filters?: Filters;
+    }): AsyncIterable<StoredItem>;
+    /** One added item by its id, whole; null when memory holds none by that id. */
+    item(itemId: string): Promise<StoredItem | null>;
+    /** How far each item has got: `queued`, `stored`, `processed` or `unknown`. */
+    status(ids: string[]): Promise<Statuses>;
+    /** Erase these items, sessions and memories (by ref), with every copy and all learned from them. */
+    forget(named: ForgetOptions): Promise<Forgotten>;
+    /** Retract one fact for good, by its ref; a `replacement` is kept as a note. */
+    correct(ref: string, replacement?: string): Promise<Correction>;
+    /** Every version of one added item, oldest first. Takes a key that writes. */
+    versions(itemId: string): Promise<Versions>;
+    /** Everything memory holds for this app user, a page at a time. */
+    export(options?: PageOptions): Promise<ExportPage>;
+    /** Every export record, across pages. */
+    iterExport(options?: {
+        limit?: number;
+    }): AsyncIterable<ExportRecord>;
+    /** Erase this app user whole: every item, fact and version. Not undone. */
+    delete(): Promise<Deleted>;
+    /**
+     * Throw `error` unless this client fails open and it is an outage; then log it, and the caller
+     * answers empty. Memory being down costs a reply its memory, not the reply.
+     */
+    private rideOut;
+}
+
+/**
+ * The client, `Memory`: one API key and the settings it sends with. `memory.user("dana")` is the
+ * memory of one of your app users.
+ */
+
+/**
+ * An Alexein client, for one API key.
+ *
+ * ```ts
+ * const memory = new Memory();          // ALEXEIN_API_KEY from the environment
+ * const dana = memory.user("dana");     // your own id for one of your app users
+ * await dana.add("I moved to Lisbon for the job at Acme.");
+ * console.log((await dana.search("Where does Dana live?")).context());
+ * ```
+ */
+declare class Memory {
+    #private;
+    /** The API's host, without `/v2`. */
+    readonly baseUrl: string;
+    /** Milliseconds one attempt may take. */
+    readonly timeout: number;
+    readonly maxRetries: number;
+    readonly failOpen: boolean;
+    /** The word in the User-Agent, or null. */
+    readonly integration: string | null;
+    constructor(options?: MemoryOptions);
+    /** What this key is: its organisation, project, and whether it writes. Names no app user. */
+    me(): Promise<Me>;
+    /**
+     * The memory of one of your app users, by your own id for them: 1 to 35 letters, digits, `.`,
+     * `_` and `-`, beginning with a letter or digit. A RangeError otherwise, before any request.
+     */
+    user(id: string): User;
+    /** The app users of this key's project with memory, a page at a time in id order. */
+    users(options?: PageOptions): Promise<UsersPage>;
+    /** Every app user with memory, across pages. */
+    iterUsers(options?: {
+        limit?: number;
+    }): AsyncIterable<AppUser>;
+    /** Nothing to release: each request is its own. Here so code written for Python reads the same. */
+    close(): void;
+}
+
+export { type Versions as $, type AddOptions as A, type Opened as B, type Correction as C, DEFAULT_BASE_URL as D, type Erased as E, type Fact as F, type GrepOptions as G, type History as H, type Item as I, type Json as J, type Known as K, type LatestOptions as L, type Me as M, type Origin as N, type OpenItem as O, type PageOptions as P, SearchResult as Q, type Source as R, type SearchOptions as S, type Sources as T, type Statuses as U, type StoredItem as V, type Summary as W, User as X, type UsersPage as Y, type Value as Z, type VersionEntry as _, type AddResult as a, type AddedItem as b, type Adding as c, type AppUser as d, type Author as e, DEFAULT_RETRIES as f, DEFAULT_TIMEOUT_MS as g, type Deleted as h, type Excerpt as i, type ExportPage as j, type ExportRecord as k, type FactsPage as l, type Filters as m, type FollowUp as n, type ForgetOptions as o, type Forgotten as p, type ItemDefaults as q, type ItemStatus as r, type ItemsOptions as s, type ItemsPage as t, type Memories as u, Memory as v, type MemoryEntry as w, type MemoryOptions as x, type OpenItems as y, type OpenItemsOptions as z };

package/dist/index.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk7KPDU3YVcjs = require('./chunk-7KPDU3YV.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.APIConnectionError = _chunk7KPDU3YVcjs.APIConnectionError; exports.APITimeoutError = _chunk7KPDU3YVcjs.APITimeoutError; exports.AlexeinError = _chunk7KPDU3YVcjs.AlexeinError; exports.AuthenticationError = _chunk7KPDU3YVcjs.AuthenticationError; exports.DEFAULT_BASE_URL = _chunk7KPDU3YVcjs.DEFAULT_BASE_URL; exports.DEFAULT_RETRIES = _chunk7KPDU3YVcjs.DEFAULT_RETRIES; exports.DEFAULT_TIMEOUT_MS = _chunk7KPDU3YVcjs.DEFAULT_TIMEOUT_MS; exports.InvalidRequestError = _chunk7KPDU3YVcjs.InvalidRequestError; exports.Memory = _chunk7KPDU3YVcjs.Memory; exports.NotFoundError = _chunk7KPDU3YVcjs.NotFoundError; exports.PermissionDeniedError = _chunk7KPDU3YVcjs.PermissionDeniedError; exports.RateLimitError = _chunk7KPDU3YVcjs.RateLimitError; exports.SearchResult = _chunk7KPDU3YVcjs.SearchResult; exports.ServiceUnavailableError = _chunk7KPDU3YVcjs.ServiceUnavailableError; exports.User = _chunk7KPDU3YVcjs.User; exports.VERSION = _chunk7KPDU3YVcjs.VERSION;