@findlane/server 0.23.0 → 0.25.0

package/dist/index.d.cts

@@ -394,6 +394,25 @@ export type SearchRequest = {
     /** Checks rules as at this time, in milliseconds since 1970, such as a campaign's start, instead of now
      * (0.20.0). Browser search doesn't take it. */
     rulesAt?: number;
+    /** The index's subindexes to search too, such as a store's categories and pages beside its products, by
+     * name: each with its own search, which takes this one's `q` and `highlight` unless it says, and 5 results
+     * unless it says, or `true` for that. Up to 5. Their results come back in `subindexes`; the search and its
+     * subindexes count as one search (0.25.0). */
+    subindexes?: Record<string, Omit<SearchRequest, "subindexes"> | true>;
+};
+/** A subindex whose search failed, such as one the index doesn't have (404). */
+export type SubindexError = {
+    error: string;
+    status: number;
+};
+/** One of an index's subindexes: its full name (products.categories), its own name, and its records. */
+export type Subindex = {
+    id: string;
+    name: string;
+    subindex: string;
+    kind: string | null;
+    status: string;
+    records: number;
 };
 /** A point in degrees: lat from -90 to 90, lng from -180 to 180. */
 export type GeoPoint = {
@@ -541,6 +560,8 @@ export type SearchResponse<T> = {
         }>;
         total: number;
     };
+    /** With `subindexes`: each subindex's results by name, or its error (0.25.0). */
+    subindexes?: Record<string, SearchResponse<JsonRecord> | SubindexError>;
 };
 /** How a product's recommendations are served (the recommendations add-on). */
 /** One of an index's lists (docs: Lists): a row of products, such as Popular or New arrivals, from a filter and
@@ -832,6 +853,71 @@ export type BannerStatsReport = {
     }[];
     analytics: "ok" | "off" | "unavailable";
 };
+export type FeedFormat = "xml" | "tsv" | "csv" | "json" | "jsonl";
+/** One run of a product feed: unchanged when the file hadn't changed; held when it would have emptied the index,
+ * removed more than half its products, or refused a fifth of its items (`message` says which). */
+export type FeedRun = {
+    id: string;
+    trigger: "schedule" | "manual" | "connect" | "held";
+    status: "running" | "unchanged" | "imported" | "held" | "failed";
+    startedAt: string;
+    finishedAt: string | null;
+    format: FeedFormat | null;
+    bytes: number | null;
+    items: number | null;
+    records: number | null;
+    added: number | null;
+    changed: number | null;
+    removed: number | null;
+    refused: number | null;
+    reasons: Record<string, number>;
+    refusals: {
+        id?: string;
+        reason: string;
+    }[];
+    message: string | null;
+};
+/** An index's product feed: where it's read from, when, and how its last run went. `password` says whether it has one. */
+export type ProductFeed = {
+    url: string;
+    username: string | null;
+    password: boolean;
+    schedule: "hourly" | "6h" | "daily";
+    hour: number | null;
+    variants: "group" | "separate";
+    paused: boolean;
+    pausedReason: "owner" | "failing" | null;
+    failures: number;
+    running: boolean;
+    nextRunAt: string | null;
+    lastRun: FeedRun | null;
+    held: FeedRun | null;
+};
+/** A feed's setup: each field given replaces the current one; null clears the username or password. */
+export type FeedSetup = {
+    url?: string;
+    username?: string | null;
+    password?: string | null;
+    schedule?: "hourly" | "6h" | "daily";
+    hour?: number;
+    variants?: "group" | "separate";
+    paused?: boolean;
+};
+/** What a feed's first 2,000 items hold: the records they make (the first five in `sample`), and refused items. */
+export type FeedCheck = {
+    format: FeedFormat | null;
+    complete: boolean;
+    items: number;
+    records: number;
+    refused: number;
+    sample: Record<string, unknown>[];
+    fields: string[];
+    reasons: Record<string, number>;
+    refusals: {
+        id?: string;
+        reason: string;
+    }[];
+};
 /** A past order for importOrders; `timestamp` is when it was placed (ms, a Date, or an ISO string). */
 export type Order = {
     orderID: string;
@@ -1158,6 +1244,25 @@ export declare class SearchServerClient {
                 deleted: true;
             }>;
         };
+        /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+         * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+         * needs the `search` or `write` scope; the rest, `write`. */
+        feed: {
+            /** The feed and its last run, or null. */
+            get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+            /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+            set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+            /** Disconnects it; the index keeps its records. */
+            remove: (signal?: AbortSignal) => Promise<void>;
+            /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+            check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+            /** Reads it now, in full, in the background; `runs` shows how it went. */
+            run: (signal?: AbortSignal) => Promise<FeedRun>;
+            /** The last 20 runs, newest first. */
+            runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+            /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+            importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+        };
         lists: {
             /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
             get: <R = T>(id: string, options?: {
@@ -1282,6 +1387,2173 @@ export declare class SearchServerClient {
             intervalMs?: number;
             signal?: AbortSignal;
         }) => Promise<CurrentSettings>;
+        /** A subindex of this index (0.25.0), such as `index("products").subindex("categories")`: an index of its own,
+         * named products.categories, searched with this one (`subindexes` in a search) and opened by its keys. */
+        subindex: <S extends {
+            objectID: string;
+        } = JsonRecord>(subindex: string) => {
+            /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+             * someone, such as a shopper loading a server-rendered page (see Visitor). */
+            search: <R = S>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+            /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+             * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+             * a search. */
+            suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+            /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+             * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+             * 10, 5 by default. */
+            querySuggestions: (query: {
+                q: string;
+                limit?: number;
+            }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+            /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+             * empty until the index has enough searches. The list changes daily. */
+            popularSearches: (options?: {
+                limit?: number;
+            }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+            /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+             * The API key needs the `search` scope; not counted as a search. */
+            recommendations: <R = S>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+            /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+             * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+             * setting them up needs `write`. */
+            /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+             * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+             * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+            merchandising: {
+                /** Every arranged category page and search. */
+                list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                 * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+            };
+            /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+             * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+             * later. Uploading and deleting need the `write` scope. */
+            images: {
+                list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                /** Uploads an image's bytes; the same image again gives the same URL. */
+                upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                    contentType?: string;
+                    signal?: AbortSignal;
+                }) => Promise<UploadedImage & {
+                    error?: string;
+                }>;
+                /** Uploads the image at an https address, which Findlane fetches. */
+                uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                delete: (key: string, signal?: AbortSignal) => Promise<{
+                    deleted: true;
+                }>;
+            };
+            /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+             * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+             * needs the `search` or `write` scope; the rest, `write`. */
+            feed: {
+                /** The feed and its last run, or null. */
+                get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                /** Disconnects it; the index keeps its records. */
+                remove: (signal?: AbortSignal) => Promise<void>;
+                /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                /** Reads it now, in full, in the background; `runs` shows how it went. */
+                run: (signal?: AbortSignal) => Promise<FeedRun>;
+                /** The last 20 runs, newest first. */
+                runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+            };
+            lists: {
+                /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                get: <R = S>(id: string, options?: {
+                    limit?: number;
+                    signal?: AbortSignal;
+                }) => Promise<List<R>>;
+                /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                getMany: <R = S>(ids?: string[], options?: {
+                    limit?: number;
+                    signal?: AbortSignal;
+                }) => Promise<List<R>[]>;
+                /** How the index's lists are set up, and their last build. */
+                settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                 * refused with why (400), and a new list past the plan's lists per index too (402). */
+                save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                /** Puts the lists in this order: every list's ID once. */
+                order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                /** What a list would hold, built without saving it. */
+                preview: <R = S>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                    list: List<R>;
+                    tookMs: number;
+                }>;
+            };
+            /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+             * scope. Orders count once each, however often they're sent. */
+            events: {
+                /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                 * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                 * cursor), 200 a request. */
+                importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                /** Takes a cancelled or refunded order out of Bought together. */
+                cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                 * within a week. 1,000 IDs a request. */
+                forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                    forgotten: number;
+                }>;
+                /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                 * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                 * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                 * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                 * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                 * and its visitor. Answers with the API's response. */
+                relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+            };
+            /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+             * requests from web pages are refused. */
+            analytics: {
+                /** Searches, searches without results and response times, beside the same span before, and a series per
+                 * hour (up to 7 days, by default) or day. */
+                searches: (options?: AnalyticsOptions & {
+                    interval?: "hour" | "day";
+                }) => Promise<SearchesReport>;
+                /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                 * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                    list?: L | undefined;
+                    limit?: number;
+                }) => Promise<QueriesReport<L>>;
+                /** The filter fields and sorts searches used. */
+                filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                events: (options?: AnalyticsOptions & {
+                    interval?: "hour" | "day";
+                }) => Promise<EventsReport>;
+                /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                 * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                 * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                 * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                 * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                product: (objectID: string, options?: AnalyticsOptions & {
+                    interval?: "hour" | "day";
+                }) => Promise<ProductReport>;
+                /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                 * product (0.20.0). */
+                revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                 * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                banners: (options?: {
+                    range?: "7d" | "30d" | "90d";
+                    signal?: AbortSignal;
+                }) => Promise<BannerStatsReport>;
+            };
+            upsert: (records: S[], signal?: AbortSignal) => Promise<WriteReceipt>;
+            getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S>>;
+            upsertOne: (record: S, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+            deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+            replaceAll: (records: S[], signal?: AbortSignal) => Promise<WriteReceipt>;
+            beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+            uploadReplacementBatch: (stageId: string, batchId: string, records: S[], signal?: AbortSignal) => Promise<ReplacementStage>;
+            commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+            abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+            replaceAllStaged: (records: Iterable<S> | AsyncIterable<S>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+            delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+            getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+            replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+            /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+             * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+             * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+             * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+             * or normalization) throws a 409: save it first. Not counted as searches. */
+            compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+            /** The index's search tests. */
+            getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+            /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+            setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+            /** Waits until no settings rebuild is running; throws if it failed. */
+            waitForSettings: (options?: {
+                timeoutMs?: number;
+                intervalMs?: number;
+                signal?: AbortSignal;
+            }) => Promise<CurrentSettings>;
+            subindex: <S_1 extends {
+                objectID: string;
+            } = JsonRecord>(subindex: string) => {
+                /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                 * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                search: <R = S_1>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                 * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                 * a search. */
+                suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                 * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                 * 10, 5 by default. */
+                querySuggestions: (query: {
+                    q: string;
+                    limit?: number;
+                }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                 * empty until the index has enough searches. The list changes daily. */
+                popularSearches: (options?: {
+                    limit?: number;
+                }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                 * The API key needs the `search` scope; not counted as a search. */
+                recommendations: <R = S_1>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                 * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                 * setting them up needs `write`. */
+                /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                 * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                 * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                merchandising: {
+                    /** Every arranged category page and search. */
+                    list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                    /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                    get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                    /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                     * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                    set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                    /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                    remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                };
+                /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                 * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                 * later. Uploading and deleting need the `write` scope. */
+                images: {
+                    list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                    /** Uploads an image's bytes; the same image again gives the same URL. */
+                    upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                        contentType?: string;
+                        signal?: AbortSignal;
+                    }) => Promise<UploadedImage & {
+                        error?: string;
+                    }>;
+                    /** Uploads the image at an https address, which Findlane fetches. */
+                    uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                    /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                    delete: (key: string, signal?: AbortSignal) => Promise<{
+                        deleted: true;
+                    }>;
+                };
+                /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                 * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                 * needs the `search` or `write` scope; the rest, `write`. */
+                feed: {
+                    /** The feed and its last run, or null. */
+                    get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                    /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                    set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                    /** Disconnects it; the index keeps its records. */
+                    remove: (signal?: AbortSignal) => Promise<void>;
+                    /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                    check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                    /** Reads it now, in full, in the background; `runs` shows how it went. */
+                    run: (signal?: AbortSignal) => Promise<FeedRun>;
+                    /** The last 20 runs, newest first. */
+                    runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                    /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                    importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                };
+                lists: {
+                    /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                    get: <R = S_1>(id: string, options?: {
+                        limit?: number;
+                        signal?: AbortSignal;
+                    }) => Promise<List<R>>;
+                    /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                    getMany: <R = S_1>(ids?: string[], options?: {
+                        limit?: number;
+                        signal?: AbortSignal;
+                    }) => Promise<List<R>[]>;
+                    /** How the index's lists are set up, and their last build. */
+                    settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                    /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                     * refused with why (400), and a new list past the plan's lists per index too (402). */
+                    save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                    delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                    /** Puts the lists in this order: every list's ID once. */
+                    order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                    /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                    refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                    /** What a list would hold, built without saving it. */
+                    preview: <R = S_1>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                        list: List<R>;
+                        tookMs: number;
+                    }>;
+                };
+                /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                 * scope. Orders count once each, however often they're sent. */
+                events: {
+                    /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                     * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                    send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                    /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                     * cursor), 200 a request. */
+                    importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                    /** Takes a cancelled or refunded order out of Bought together. */
+                    cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                    /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                     * within a week. 1,000 IDs a request. */
+                    forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                        forgotten: number;
+                    }>;
+                    /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                     * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                     * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                     * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                     * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                    proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                    /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                     * and its visitor. Answers with the API's response. */
+                    relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                };
+                /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                 * requests from web pages are refused. */
+                analytics: {
+                    /** Searches, searches without results and response times, beside the same span before, and a series per
+                     * hour (up to 7 days, by default) or day. */
+                    searches: (options?: AnalyticsOptions & {
+                        interval?: "hour" | "day";
+                    }) => Promise<SearchesReport>;
+                    /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                     * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                    queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                        list?: L | undefined;
+                        limit?: number;
+                    }) => Promise<QueriesReport<L>>;
+                    /** The filter fields and sorts searches used. */
+                    filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                    /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                    events: (options?: AnalyticsOptions & {
+                        interval?: "hour" | "day";
+                    }) => Promise<EventsReport>;
+                    /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                     * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                    products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                    /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                     * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                    productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                    /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                     * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                     * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                    product: (objectID: string, options?: AnalyticsOptions & {
+                        interval?: "hour" | "day";
+                    }) => Promise<ProductReport>;
+                    /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                     * product (0.20.0). */
+                    revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                    /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                     * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                    banners: (options?: {
+                        range?: "7d" | "30d" | "90d";
+                        signal?: AbortSignal;
+                    }) => Promise<BannerStatsReport>;
+                };
+                upsert: (records: S_1[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_1>>;
+                upsertOne: (record: S_1, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                replaceAll: (records: S_1[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                uploadReplacementBatch: (stageId: string, batchId: string, records: S_1[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                replaceAllStaged: (records: Iterable<S_1> | AsyncIterable<S_1>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                 * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                 * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                 * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                 * or normalization) throws a 409: save it first. Not counted as searches. */
+                compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                /** The index's search tests. */
+                getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                /** Waits until no settings rebuild is running; throws if it failed. */
+                waitForSettings: (options?: {
+                    timeoutMs?: number;
+                    intervalMs?: number;
+                    signal?: AbortSignal;
+                }) => Promise<CurrentSettings>;
+                subindex: <S_2 extends {
+                    objectID: string;
+                } = JsonRecord>(subindex: string) => {
+                    /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                     * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                    search: <R = S_2>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                    /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                     * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                     * a search. */
+                    suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                    /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                     * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                     * 10, 5 by default. */
+                    querySuggestions: (query: {
+                        q: string;
+                        limit?: number;
+                    }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                    /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                     * empty until the index has enough searches. The list changes daily. */
+                    popularSearches: (options?: {
+                        limit?: number;
+                    }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                    /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                     * The API key needs the `search` scope; not counted as a search. */
+                    recommendations: <R = S_2>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                    /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                     * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                     * setting them up needs `write`. */
+                    /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                     * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                     * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                    merchandising: {
+                        /** Every arranged category page and search. */
+                        list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                        /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                        get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                        /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                         * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                        set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                        /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                        remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                    };
+                    /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                     * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                     * later. Uploading and deleting need the `write` scope. */
+                    images: {
+                        list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                        /** Uploads an image's bytes; the same image again gives the same URL. */
+                        upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                            contentType?: string;
+                            signal?: AbortSignal;
+                        }) => Promise<UploadedImage & {
+                            error?: string;
+                        }>;
+                        /** Uploads the image at an https address, which Findlane fetches. */
+                        uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                        /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                        delete: (key: string, signal?: AbortSignal) => Promise<{
+                            deleted: true;
+                        }>;
+                    };
+                    /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                     * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                     * needs the `search` or `write` scope; the rest, `write`. */
+                    feed: {
+                        /** The feed and its last run, or null. */
+                        get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                        /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                        set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                        /** Disconnects it; the index keeps its records. */
+                        remove: (signal?: AbortSignal) => Promise<void>;
+                        /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                        check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                        /** Reads it now, in full, in the background; `runs` shows how it went. */
+                        run: (signal?: AbortSignal) => Promise<FeedRun>;
+                        /** The last 20 runs, newest first. */
+                        runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                        /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                        importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                    };
+                    lists: {
+                        /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                        get: <R = S_2>(id: string, options?: {
+                            limit?: number;
+                            signal?: AbortSignal;
+                        }) => Promise<List<R>>;
+                        /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                        getMany: <R = S_2>(ids?: string[], options?: {
+                            limit?: number;
+                            signal?: AbortSignal;
+                        }) => Promise<List<R>[]>;
+                        /** How the index's lists are set up, and their last build. */
+                        settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                        /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                         * refused with why (400), and a new list past the plan's lists per index too (402). */
+                        save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                        delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                        /** Puts the lists in this order: every list's ID once. */
+                        order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                        /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                        refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                        /** What a list would hold, built without saving it. */
+                        preview: <R = S_2>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                            list: List<R>;
+                            tookMs: number;
+                        }>;
+                    };
+                    /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                     * scope. Orders count once each, however often they're sent. */
+                    events: {
+                        /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                         * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                        send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                        /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                         * cursor), 200 a request. */
+                        importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                        /** Takes a cancelled or refunded order out of Bought together. */
+                        cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                        /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                         * within a week. 1,000 IDs a request. */
+                        forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                            forgotten: number;
+                        }>;
+                        /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                         * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                         * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                         * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                         * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                        proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                        /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                         * and its visitor. Answers with the API's response. */
+                        relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                    };
+                    /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                     * requests from web pages are refused. */
+                    analytics: {
+                        /** Searches, searches without results and response times, beside the same span before, and a series per
+                         * hour (up to 7 days, by default) or day. */
+                        searches: (options?: AnalyticsOptions & {
+                            interval?: "hour" | "day";
+                        }) => Promise<SearchesReport>;
+                        /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                         * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                        queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                            list?: L | undefined;
+                            limit?: number;
+                        }) => Promise<QueriesReport<L>>;
+                        /** The filter fields and sorts searches used. */
+                        filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                        /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                        events: (options?: AnalyticsOptions & {
+                            interval?: "hour" | "day";
+                        }) => Promise<EventsReport>;
+                        /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                         * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                        products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                        /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                         * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                        productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                        /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                         * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                         * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                        product: (objectID: string, options?: AnalyticsOptions & {
+                            interval?: "hour" | "day";
+                        }) => Promise<ProductReport>;
+                        /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                         * product (0.20.0). */
+                        revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                        /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                         * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                        banners: (options?: {
+                            range?: "7d" | "30d" | "90d";
+                            signal?: AbortSignal;
+                        }) => Promise<BannerStatsReport>;
+                    };
+                    upsert: (records: S_2[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                    getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_2>>;
+                    upsertOne: (record: S_2, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                    deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                    replaceAll: (records: S_2[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                    beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                    uploadReplacementBatch: (stageId: string, batchId: string, records: S_2[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                    commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                    abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                    replaceAllStaged: (records: Iterable<S_2> | AsyncIterable<S_2>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                    delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                    getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                    replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                    /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                     * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                     * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                     * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                     * or normalization) throws a 409: save it first. Not counted as searches. */
+                    compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                    /** The index's search tests. */
+                    getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                    /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                    setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                    /** Waits until no settings rebuild is running; throws if it failed. */
+                    waitForSettings: (options?: {
+                        timeoutMs?: number;
+                        intervalMs?: number;
+                        signal?: AbortSignal;
+                    }) => Promise<CurrentSettings>;
+                    subindex: <S_3 extends {
+                        objectID: string;
+                    } = JsonRecord>(subindex: string) => {
+                        /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                         * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                        search: <R = S_3>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                        /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                         * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                         * a search. */
+                        suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                        /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                         * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                         * 10, 5 by default. */
+                        querySuggestions: (query: {
+                            q: string;
+                            limit?: number;
+                        }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                        /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                         * empty until the index has enough searches. The list changes daily. */
+                        popularSearches: (options?: {
+                            limit?: number;
+                        }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                        /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                         * The API key needs the `search` scope; not counted as a search. */
+                        recommendations: <R = S_3>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                        /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                         * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                         * setting them up needs `write`. */
+                        /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                         * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                         * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                        merchandising: {
+                            /** Every arranged category page and search. */
+                            list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                            /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                            get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                            /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                             * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                            set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                            /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                            remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                        };
+                        /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                         * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                         * later. Uploading and deleting need the `write` scope. */
+                        images: {
+                            list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                            /** Uploads an image's bytes; the same image again gives the same URL. */
+                            upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                                contentType?: string;
+                                signal?: AbortSignal;
+                            }) => Promise<UploadedImage & {
+                                error?: string;
+                            }>;
+                            /** Uploads the image at an https address, which Findlane fetches. */
+                            uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                            /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                            delete: (key: string, signal?: AbortSignal) => Promise<{
+                                deleted: true;
+                            }>;
+                        };
+                        /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                         * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                         * needs the `search` or `write` scope; the rest, `write`. */
+                        feed: {
+                            /** The feed and its last run, or null. */
+                            get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                            /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                            set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                            /** Disconnects it; the index keeps its records. */
+                            remove: (signal?: AbortSignal) => Promise<void>;
+                            /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                            check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                            /** Reads it now, in full, in the background; `runs` shows how it went. */
+                            run: (signal?: AbortSignal) => Promise<FeedRun>;
+                            /** The last 20 runs, newest first. */
+                            runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                            /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                            importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                        };
+                        lists: {
+                            /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                            get: <R = S_3>(id: string, options?: {
+                                limit?: number;
+                                signal?: AbortSignal;
+                            }) => Promise<List<R>>;
+                            /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                            getMany: <R = S_3>(ids?: string[], options?: {
+                                limit?: number;
+                                signal?: AbortSignal;
+                            }) => Promise<List<R>[]>;
+                            /** How the index's lists are set up, and their last build. */
+                            settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                            /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                             * refused with why (400), and a new list past the plan's lists per index too (402). */
+                            save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                            delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                            /** Puts the lists in this order: every list's ID once. */
+                            order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                            /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                            refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                            /** What a list would hold, built without saving it. */
+                            preview: <R = S_3>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                                list: List<R>;
+                                tookMs: number;
+                            }>;
+                        };
+                        /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                         * scope. Orders count once each, however often they're sent. */
+                        events: {
+                            /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                             * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                            send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                            /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                             * cursor), 200 a request. */
+                            importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                            /** Takes a cancelled or refunded order out of Bought together. */
+                            cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                            /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                             * within a week. 1,000 IDs a request. */
+                            forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                                forgotten: number;
+                            }>;
+                            /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                             * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                             * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                             * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                             * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                            proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                            /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                             * and its visitor. Answers with the API's response. */
+                            relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                        };
+                        /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                         * requests from web pages are refused. */
+                        analytics: {
+                            /** Searches, searches without results and response times, beside the same span before, and a series per
+                             * hour (up to 7 days, by default) or day. */
+                            searches: (options?: AnalyticsOptions & {
+                                interval?: "hour" | "day";
+                            }) => Promise<SearchesReport>;
+                            /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                             * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                            queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                                list?: L | undefined;
+                                limit?: number;
+                            }) => Promise<QueriesReport<L>>;
+                            /** The filter fields and sorts searches used. */
+                            filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                            /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                            events: (options?: AnalyticsOptions & {
+                                interval?: "hour" | "day";
+                            }) => Promise<EventsReport>;
+                            /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                             * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                            products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                            /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                             * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                            productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                            /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                             * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                             * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                            product: (objectID: string, options?: AnalyticsOptions & {
+                                interval?: "hour" | "day";
+                            }) => Promise<ProductReport>;
+                            /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                             * product (0.20.0). */
+                            revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                            /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                             * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                            banners: (options?: {
+                                range?: "7d" | "30d" | "90d";
+                                signal?: AbortSignal;
+                            }) => Promise<BannerStatsReport>;
+                        };
+                        upsert: (records: S_3[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                        getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_3>>;
+                        upsertOne: (record: S_3, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                        deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                        replaceAll: (records: S_3[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                        beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                        uploadReplacementBatch: (stageId: string, batchId: string, records: S_3[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                        commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                        abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                        replaceAllStaged: (records: Iterable<S_3> | AsyncIterable<S_3>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                        delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                        getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                        replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                        /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                         * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                         * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                         * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                         * or normalization) throws a 409: save it first. Not counted as searches. */
+                        compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                        /** The index's search tests. */
+                        getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                        /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                        setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                        /** Waits until no settings rebuild is running; throws if it failed. */
+                        waitForSettings: (options?: {
+                            timeoutMs?: number;
+                            intervalMs?: number;
+                            signal?: AbortSignal;
+                        }) => Promise<CurrentSettings>;
+                        subindex: <S_4 extends {
+                            objectID: string;
+                        } = JsonRecord>(subindex: string) => {
+                            /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                             * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                            search: <R = S_4>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                            /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                             * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                             * a search. */
+                            suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                            /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                             * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                             * 10, 5 by default. */
+                            querySuggestions: (query: {
+                                q: string;
+                                limit?: number;
+                            }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                            /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                             * empty until the index has enough searches. The list changes daily. */
+                            popularSearches: (options?: {
+                                limit?: number;
+                            }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                            /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                             * The API key needs the `search` scope; not counted as a search. */
+                            recommendations: <R = S_4>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                            /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                             * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                             * setting them up needs `write`. */
+                            /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                             * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                             * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                            merchandising: {
+                                /** Every arranged category page and search. */
+                                list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                                /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                                get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                                 * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                                set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                                /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                                remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                            };
+                            /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                             * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                             * later. Uploading and deleting need the `write` scope. */
+                            images: {
+                                list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                                /** Uploads an image's bytes; the same image again gives the same URL. */
+                                upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                                    contentType?: string;
+                                    signal?: AbortSignal;
+                                }) => Promise<UploadedImage & {
+                                    error?: string;
+                                }>;
+                                /** Uploads the image at an https address, which Findlane fetches. */
+                                uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                                /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                                delete: (key: string, signal?: AbortSignal) => Promise<{
+                                    deleted: true;
+                                }>;
+                            };
+                            /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                             * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                             * needs the `search` or `write` scope; the rest, `write`. */
+                            feed: {
+                                /** The feed and its last run, or null. */
+                                get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                                /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                                set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                                /** Disconnects it; the index keeps its records. */
+                                remove: (signal?: AbortSignal) => Promise<void>;
+                                /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                                check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                                /** Reads it now, in full, in the background; `runs` shows how it went. */
+                                run: (signal?: AbortSignal) => Promise<FeedRun>;
+                                /** The last 20 runs, newest first. */
+                                runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                                /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                                importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                            };
+                            lists: {
+                                /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                                get: <R = S_4>(id: string, options?: {
+                                    limit?: number;
+                                    signal?: AbortSignal;
+                                }) => Promise<List<R>>;
+                                /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                                getMany: <R = S_4>(ids?: string[], options?: {
+                                    limit?: number;
+                                    signal?: AbortSignal;
+                                }) => Promise<List<R>[]>;
+                                /** How the index's lists are set up, and their last build. */
+                                settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                                /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                                 * refused with why (400), and a new list past the plan's lists per index too (402). */
+                                save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                                delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                                /** Puts the lists in this order: every list's ID once. */
+                                order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                                /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                                refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                                /** What a list would hold, built without saving it. */
+                                preview: <R = S_4>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                                    list: List<R>;
+                                    tookMs: number;
+                                }>;
+                            };
+                            /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                             * scope. Orders count once each, however often they're sent. */
+                            events: {
+                                /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                                 * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                                send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                                /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                                 * cursor), 200 a request. */
+                                importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                                /** Takes a cancelled or refunded order out of Bought together. */
+                                cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                                /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                                 * within a week. 1,000 IDs a request. */
+                                forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                                    forgotten: number;
+                                }>;
+                                /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                                 * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                                 * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                                 * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                                 * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                                proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                                /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                                 * and its visitor. Answers with the API's response. */
+                                relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                            };
+                            /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                             * requests from web pages are refused. */
+                            analytics: {
+                                /** Searches, searches without results and response times, beside the same span before, and a series per
+                                 * hour (up to 7 days, by default) or day. */
+                                searches: (options?: AnalyticsOptions & {
+                                    interval?: "hour" | "day";
+                                }) => Promise<SearchesReport>;
+                                /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                                 * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                                queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                                    list?: L | undefined;
+                                    limit?: number;
+                                }) => Promise<QueriesReport<L>>;
+                                /** The filter fields and sorts searches used. */
+                                filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                                /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                                events: (options?: AnalyticsOptions & {
+                                    interval?: "hour" | "day";
+                                }) => Promise<EventsReport>;
+                                /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                                 * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                                products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                                /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                                 * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                                productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                                /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                                 * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                                 * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                                product: (objectID: string, options?: AnalyticsOptions & {
+                                    interval?: "hour" | "day";
+                                }) => Promise<ProductReport>;
+                                /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                                 * product (0.20.0). */
+                                revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                                /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                                 * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                                banners: (options?: {
+                                    range?: "7d" | "30d" | "90d";
+                                    signal?: AbortSignal;
+                                }) => Promise<BannerStatsReport>;
+                            };
+                            upsert: (records: S_4[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                            getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_4>>;
+                            upsertOne: (record: S_4, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                            deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                            replaceAll: (records: S_4[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                            beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                            uploadReplacementBatch: (stageId: string, batchId: string, records: S_4[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                            commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                            abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                            replaceAllStaged: (records: Iterable<S_4> | AsyncIterable<S_4>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                            delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                            getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                            replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                            /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                             * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                             * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                             * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                             * or normalization) throws a 409: save it first. Not counted as searches. */
+                            compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                            /** The index's search tests. */
+                            getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                            /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                            setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                            /** Waits until no settings rebuild is running; throws if it failed. */
+                            waitForSettings: (options?: {
+                                timeoutMs?: number;
+                                intervalMs?: number;
+                                signal?: AbortSignal;
+                            }) => Promise<CurrentSettings>;
+                            subindex: <S_5 extends {
+                                objectID: string;
+                            } = JsonRecord>(subindex: string) => {
+                                /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                                 * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                                search: <R = S_5>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                                /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                                 * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                                 * a search. */
+                                suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                                /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                                 * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                                 * 10, 5 by default. */
+                                querySuggestions: (query: {
+                                    q: string;
+                                    limit?: number;
+                                }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                                 * empty until the index has enough searches. The list changes daily. */
+                                popularSearches: (options?: {
+                                    limit?: number;
+                                }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                                 * The API key needs the `search` scope; not counted as a search. */
+                                recommendations: <R = S_5>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                                /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                                 * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                                 * setting them up needs `write`. */
+                                /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                                 * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                                 * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                                merchandising: {
+                                    /** Every arranged category page and search. */
+                                    list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                                    /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                                    get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                    /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                                     * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                                    set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                                    /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                                    remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                };
+                                /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                                 * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                                 * later. Uploading and deleting need the `write` scope. */
+                                images: {
+                                    list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                                    /** Uploads an image's bytes; the same image again gives the same URL. */
+                                    upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                                        contentType?: string;
+                                        signal?: AbortSignal;
+                                    }) => Promise<UploadedImage & {
+                                        error?: string;
+                                    }>;
+                                    /** Uploads the image at an https address, which Findlane fetches. */
+                                    uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                                    /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                                    delete: (key: string, signal?: AbortSignal) => Promise<{
+                                        deleted: true;
+                                    }>;
+                                };
+                                /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                                 * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                                 * needs the `search` or `write` scope; the rest, `write`. */
+                                feed: {
+                                    /** The feed and its last run, or null. */
+                                    get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                                    /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                                    set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                                    /** Disconnects it; the index keeps its records. */
+                                    remove: (signal?: AbortSignal) => Promise<void>;
+                                    /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                                    check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                                    /** Reads it now, in full, in the background; `runs` shows how it went. */
+                                    run: (signal?: AbortSignal) => Promise<FeedRun>;
+                                    /** The last 20 runs, newest first. */
+                                    runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                                    /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                                    importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                                };
+                                lists: {
+                                    /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                                    get: <R = S_5>(id: string, options?: {
+                                        limit?: number;
+                                        signal?: AbortSignal;
+                                    }) => Promise<List<R>>;
+                                    /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                                    getMany: <R = S_5>(ids?: string[], options?: {
+                                        limit?: number;
+                                        signal?: AbortSignal;
+                                    }) => Promise<List<R>[]>;
+                                    /** How the index's lists are set up, and their last build. */
+                                    settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                                    /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                                     * refused with why (400), and a new list past the plan's lists per index too (402). */
+                                    save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                                    delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                                    /** Puts the lists in this order: every list's ID once. */
+                                    order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                                    /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                                    refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                                    /** What a list would hold, built without saving it. */
+                                    preview: <R = S_5>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                                        list: List<R>;
+                                        tookMs: number;
+                                    }>;
+                                };
+                                /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                                 * scope. Orders count once each, however often they're sent. */
+                                events: {
+                                    /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                                     * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                                    send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                                    /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                                     * cursor), 200 a request. */
+                                    importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                                    /** Takes a cancelled or refunded order out of Bought together. */
+                                    cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                                    /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                                     * within a week. 1,000 IDs a request. */
+                                    forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                                        forgotten: number;
+                                    }>;
+                                    /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                                     * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                                     * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                                     * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                                     * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                                    proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                                    /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                                     * and its visitor. Answers with the API's response. */
+                                    relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                                };
+                                /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                                 * requests from web pages are refused. */
+                                analytics: {
+                                    /** Searches, searches without results and response times, beside the same span before, and a series per
+                                     * hour (up to 7 days, by default) or day. */
+                                    searches: (options?: AnalyticsOptions & {
+                                        interval?: "hour" | "day";
+                                    }) => Promise<SearchesReport>;
+                                    /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                                     * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                                    queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                                        list?: L | undefined;
+                                        limit?: number;
+                                    }) => Promise<QueriesReport<L>>;
+                                    /** The filter fields and sorts searches used. */
+                                    filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                                    /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                                    events: (options?: AnalyticsOptions & {
+                                        interval?: "hour" | "day";
+                                    }) => Promise<EventsReport>;
+                                    /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                                     * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                                    products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                                    /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                                     * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                                    productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                                    /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                                     * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                                     * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                                    product: (objectID: string, options?: AnalyticsOptions & {
+                                        interval?: "hour" | "day";
+                                    }) => Promise<ProductReport>;
+                                    /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                                     * product (0.20.0). */
+                                    revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                                    /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                                     * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                                    banners: (options?: {
+                                        range?: "7d" | "30d" | "90d";
+                                        signal?: AbortSignal;
+                                    }) => Promise<BannerStatsReport>;
+                                };
+                                upsert: (records: S_5[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_5>>;
+                                upsertOne: (record: S_5, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                replaceAll: (records: S_5[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                uploadReplacementBatch: (stageId: string, batchId: string, records: S_5[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                                commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                replaceAllStaged: (records: Iterable<S_5> | AsyncIterable<S_5>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                                delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                                replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                                /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                                 * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                                 * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                                 * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                                 * or normalization) throws a 409: save it first. Not counted as searches. */
+                                compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                                /** The index's search tests. */
+                                getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                                /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                                setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                                /** Waits until no settings rebuild is running; throws if it failed. */
+                                waitForSettings: (options?: {
+                                    timeoutMs?: number;
+                                    intervalMs?: number;
+                                    signal?: AbortSignal;
+                                }) => Promise<CurrentSettings>;
+                                subindex: <S_6 extends {
+                                    objectID: string;
+                                } = JsonRecord>(subindex: string) => {
+                                    /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                                     * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                                    search: <R = S_6>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                                    /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                                     * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                                     * a search. */
+                                    suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                                    /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                                     * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                                     * 10, 5 by default. */
+                                    querySuggestions: (query: {
+                                        q: string;
+                                        limit?: number;
+                                    }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                    /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                                     * empty until the index has enough searches. The list changes daily. */
+                                    popularSearches: (options?: {
+                                        limit?: number;
+                                    }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                    /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                                     * The API key needs the `search` scope; not counted as a search. */
+                                    recommendations: <R = S_6>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                                    /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                                     * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                                     * setting them up needs `write`. */
+                                    /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                                     * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                                     * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                                    merchandising: {
+                                        /** Every arranged category page and search. */
+                                        list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                                        /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                                        get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                        /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                                         * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                                        set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                                        /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                                        remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                    };
+                                    /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                                     * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                                     * later. Uploading and deleting need the `write` scope. */
+                                    images: {
+                                        list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                                        /** Uploads an image's bytes; the same image again gives the same URL. */
+                                        upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                                            contentType?: string;
+                                            signal?: AbortSignal;
+                                        }) => Promise<UploadedImage & {
+                                            error?: string;
+                                        }>;
+                                        /** Uploads the image at an https address, which Findlane fetches. */
+                                        uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                                        /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                                        delete: (key: string, signal?: AbortSignal) => Promise<{
+                                            deleted: true;
+                                        }>;
+                                    };
+                                    /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                                     * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                                     * needs the `search` or `write` scope; the rest, `write`. */
+                                    feed: {
+                                        /** The feed and its last run, or null. */
+                                        get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                                        /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                                        set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                                        /** Disconnects it; the index keeps its records. */
+                                        remove: (signal?: AbortSignal) => Promise<void>;
+                                        /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                                        check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                                        /** Reads it now, in full, in the background; `runs` shows how it went. */
+                                        run: (signal?: AbortSignal) => Promise<FeedRun>;
+                                        /** The last 20 runs, newest first. */
+                                        runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                                        /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                                        importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                                    };
+                                    lists: {
+                                        /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                                        get: <R = S_6>(id: string, options?: {
+                                            limit?: number;
+                                            signal?: AbortSignal;
+                                        }) => Promise<List<R>>;
+                                        /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                                        getMany: <R = S_6>(ids?: string[], options?: {
+                                            limit?: number;
+                                            signal?: AbortSignal;
+                                        }) => Promise<List<R>[]>;
+                                        /** How the index's lists are set up, and their last build. */
+                                        settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                                        /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                                         * refused with why (400), and a new list past the plan's lists per index too (402). */
+                                        save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                                        delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                                        /** Puts the lists in this order: every list's ID once. */
+                                        order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                                        /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                                        refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                                        /** What a list would hold, built without saving it. */
+                                        preview: <R = S_6>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                                            list: List<R>;
+                                            tookMs: number;
+                                        }>;
+                                    };
+                                    /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                                     * scope. Orders count once each, however often they're sent. */
+                                    events: {
+                                        /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                                         * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                                        send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                                        /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                                         * cursor), 200 a request. */
+                                        importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                                        /** Takes a cancelled or refunded order out of Bought together. */
+                                        cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                                        /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                                         * within a week. 1,000 IDs a request. */
+                                        forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                                            forgotten: number;
+                                        }>;
+                                        /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                                         * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                                         * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                                         * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                                         * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                                        proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                                        /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                                         * and its visitor. Answers with the API's response. */
+                                        relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                                    };
+                                    /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                                     * requests from web pages are refused. */
+                                    analytics: {
+                                        /** Searches, searches without results and response times, beside the same span before, and a series per
+                                         * hour (up to 7 days, by default) or day. */
+                                        searches: (options?: AnalyticsOptions & {
+                                            interval?: "hour" | "day";
+                                        }) => Promise<SearchesReport>;
+                                        /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                                         * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                                        queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                                            list?: L | undefined;
+                                            limit?: number;
+                                        }) => Promise<QueriesReport<L>>;
+                                        /** The filter fields and sorts searches used. */
+                                        filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                                        /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                                        events: (options?: AnalyticsOptions & {
+                                            interval?: "hour" | "day";
+                                        }) => Promise<EventsReport>;
+                                        /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                                         * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                                        products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                                        /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                                         * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                                        productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                                        /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                                         * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                                         * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                                        product: (objectID: string, options?: AnalyticsOptions & {
+                                            interval?: "hour" | "day";
+                                        }) => Promise<ProductReport>;
+                                        /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                                         * product (0.20.0). */
+                                        revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                                        /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                                         * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                                        banners: (options?: {
+                                            range?: "7d" | "30d" | "90d";
+                                            signal?: AbortSignal;
+                                        }) => Promise<BannerStatsReport>;
+                                    };
+                                    upsert: (records: S_6[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                    getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_6>>;
+                                    upsertOne: (record: S_6, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                    deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                    replaceAll: (records: S_6[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                    beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                    uploadReplacementBatch: (stageId: string, batchId: string, records: S_6[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                                    commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                    abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                    replaceAllStaged: (records: Iterable<S_6> | AsyncIterable<S_6>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                                    delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                    getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                                    replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                                    /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                                     * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                                     * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                                     * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                                     * or normalization) throws a 409: save it first. Not counted as searches. */
+                                    compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                                    /** The index's search tests. */
+                                    getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                                    /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                                    setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                                    /** Waits until no settings rebuild is running; throws if it failed. */
+                                    waitForSettings: (options?: {
+                                        timeoutMs?: number;
+                                        intervalMs?: number;
+                                        signal?: AbortSignal;
+                                    }) => Promise<CurrentSettings>;
+                                    subindex: <S_7 extends {
+                                        objectID: string;
+                                    } = JsonRecord>(subindex: string) => {
+                                        /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                                         * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                                        search: <R = S_7>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                                        /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                                         * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                                         * a search. */
+                                        suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                                        /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                                         * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                                         * 10, 5 by default. */
+                                        querySuggestions: (query: {
+                                            q: string;
+                                            limit?: number;
+                                        }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                        /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                                         * empty until the index has enough searches. The list changes daily. */
+                                        popularSearches: (options?: {
+                                            limit?: number;
+                                        }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                        /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                                         * The API key needs the `search` scope; not counted as a search. */
+                                        recommendations: <R = S_7>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                                        /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                                         * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                                         * setting them up needs `write`. */
+                                        /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                                         * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                                         * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                                        merchandising: {
+                                            /** Every arranged category page and search. */
+                                            list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                                            /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                                            get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                            /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                                             * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                                            set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                                            /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                                            remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                        };
+                                        /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                                         * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                                         * later. Uploading and deleting need the `write` scope. */
+                                        images: {
+                                            list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                                            /** Uploads an image's bytes; the same image again gives the same URL. */
+                                            upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                                                contentType?: string;
+                                                signal?: AbortSignal;
+                                            }) => Promise<UploadedImage & {
+                                                error?: string;
+                                            }>;
+                                            /** Uploads the image at an https address, which Findlane fetches. */
+                                            uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                                            /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                                            delete: (key: string, signal?: AbortSignal) => Promise<{
+                                                deleted: true;
+                                            }>;
+                                        };
+                                        /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                                         * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                                         * needs the `search` or `write` scope; the rest, `write`. */
+                                        feed: {
+                                            /** The feed and its last run, or null. */
+                                            get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                                            /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                                            set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                                            /** Disconnects it; the index keeps its records. */
+                                            remove: (signal?: AbortSignal) => Promise<void>;
+                                            /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                                            check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                                            /** Reads it now, in full, in the background; `runs` shows how it went. */
+                                            run: (signal?: AbortSignal) => Promise<FeedRun>;
+                                            /** The last 20 runs, newest first. */
+                                            runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                                            /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                                            importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                                        };
+                                        lists: {
+                                            /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                                            get: <R = S_7>(id: string, options?: {
+                                                limit?: number;
+                                                signal?: AbortSignal;
+                                            }) => Promise<List<R>>;
+                                            /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                                            getMany: <R = S_7>(ids?: string[], options?: {
+                                                limit?: number;
+                                                signal?: AbortSignal;
+                                            }) => Promise<List<R>[]>;
+                                            /** How the index's lists are set up, and their last build. */
+                                            settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                                            /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                                             * refused with why (400), and a new list past the plan's lists per index too (402). */
+                                            save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                                            delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                                            /** Puts the lists in this order: every list's ID once. */
+                                            order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                                            /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                                            refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                                            /** What a list would hold, built without saving it. */
+                                            preview: <R = S_7>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                                                list: List<R>;
+                                                tookMs: number;
+                                            }>;
+                                        };
+                                        /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                                         * scope. Orders count once each, however often they're sent. */
+                                        events: {
+                                            /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                                             * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                                            send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                                            /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                                             * cursor), 200 a request. */
+                                            importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                                            /** Takes a cancelled or refunded order out of Bought together. */
+                                            cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                                            /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                                             * within a week. 1,000 IDs a request. */
+                                            forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                                                forgotten: number;
+                                            }>;
+                                            /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                                             * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                                             * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                                             * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                                             * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                                            proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                                            /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                                             * and its visitor. Answers with the API's response. */
+                                            relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                                        };
+                                        /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                                         * requests from web pages are refused. */
+                                        analytics: {
+                                            /** Searches, searches without results and response times, beside the same span before, and a series per
+                                             * hour (up to 7 days, by default) or day. */
+                                            searches: (options?: AnalyticsOptions & {
+                                                interval?: "hour" | "day";
+                                            }) => Promise<SearchesReport>;
+                                            /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                                             * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                                            queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                                                list?: L | undefined;
+                                                limit?: number;
+                                            }) => Promise<QueriesReport<L>>;
+                                            /** The filter fields and sorts searches used. */
+                                            filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                                            /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                                            events: (options?: AnalyticsOptions & {
+                                                interval?: "hour" | "day";
+                                            }) => Promise<EventsReport>;
+                                            /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                                             * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                                            products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                                            /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                                             * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                                            productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                                            /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                                             * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                                             * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                                            product: (objectID: string, options?: AnalyticsOptions & {
+                                                interval?: "hour" | "day";
+                                            }) => Promise<ProductReport>;
+                                            /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                                             * product (0.20.0). */
+                                            revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                                            /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                                             * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                                            banners: (options?: {
+                                                range?: "7d" | "30d" | "90d";
+                                                signal?: AbortSignal;
+                                            }) => Promise<BannerStatsReport>;
+                                        };
+                                        upsert: (records: S_7[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                        getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_7>>;
+                                        upsertOne: (record: S_7, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                        deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                        replaceAll: (records: S_7[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                        beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                        uploadReplacementBatch: (stageId: string, batchId: string, records: S_7[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                                        commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                        abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                        replaceAllStaged: (records: Iterable<S_7> | AsyncIterable<S_7>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                                        delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                        getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                                        replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                                        /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                                         * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                                         * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                                         * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                                         * or normalization) throws a 409: save it first. Not counted as searches. */
+                                        compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                                        /** The index's search tests. */
+                                        getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                                        /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                                        setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                                        /** Waits until no settings rebuild is running; throws if it failed. */
+                                        waitForSettings: (options?: {
+                                            timeoutMs?: number;
+                                            intervalMs?: number;
+                                            signal?: AbortSignal;
+                                        }) => Promise<CurrentSettings>;
+                                        subindex: <S_8 extends {
+                                            objectID: string;
+                                        } = JsonRecord>(subindex: string) => {
+                                            /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                                             * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                                            search: <R = S_8>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                                            /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                                             * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                                             * a search. */
+                                            suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                                            /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                                             * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                                             * 10, 5 by default. */
+                                            querySuggestions: (query: {
+                                                q: string;
+                                                limit?: number;
+                                            }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                            /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                                             * empty until the index has enough searches. The list changes daily. */
+                                            popularSearches: (options?: {
+                                                limit?: number;
+                                            }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                            /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                                             * The API key needs the `search` scope; not counted as a search. */
+                                            recommendations: <R = S_8>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                                            /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                                             * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                                             * setting them up needs `write`. */
+                                            /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                                             * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                                             * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                                            merchandising: {
+                                                /** Every arranged category page and search. */
+                                                list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                                                /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                                                get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                                /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                                                 * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                                                set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                                                /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                                                remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                            };
+                                            /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                                             * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                                             * later. Uploading and deleting need the `write` scope. */
+                                            images: {
+                                                list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                                                /** Uploads an image's bytes; the same image again gives the same URL. */
+                                                upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                                                    contentType?: string;
+                                                    signal?: AbortSignal;
+                                                }) => Promise<UploadedImage & {
+                                                    error?: string;
+                                                }>;
+                                                /** Uploads the image at an https address, which Findlane fetches. */
+                                                uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                                                /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                                                delete: (key: string, signal?: AbortSignal) => Promise<{
+                                                    deleted: true;
+                                                }>;
+                                            };
+                                            /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                                             * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                                             * needs the `search` or `write` scope; the rest, `write`. */
+                                            feed: {
+                                                /** The feed and its last run, or null. */
+                                                get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                                                /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                                                set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                                                /** Disconnects it; the index keeps its records. */
+                                                remove: (signal?: AbortSignal) => Promise<void>;
+                                                /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                                                check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                                                /** Reads it now, in full, in the background; `runs` shows how it went. */
+                                                run: (signal?: AbortSignal) => Promise<FeedRun>;
+                                                /** The last 20 runs, newest first. */
+                                                runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                                                /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                                                importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                                            };
+                                            lists: {
+                                                /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                                                get: <R = S_8>(id: string, options?: {
+                                                    limit?: number;
+                                                    signal?: AbortSignal;
+                                                }) => Promise<List<R>>;
+                                                /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                                                getMany: <R = S_8>(ids?: string[], options?: {
+                                                    limit?: number;
+                                                    signal?: AbortSignal;
+                                                }) => Promise<List<R>[]>;
+                                                /** How the index's lists are set up, and their last build. */
+                                                settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                                                /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                                                 * refused with why (400), and a new list past the plan's lists per index too (402). */
+                                                save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                                                delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                                                /** Puts the lists in this order: every list's ID once. */
+                                                order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                                                /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                                                refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                                                /** What a list would hold, built without saving it. */
+                                                preview: <R = S_8>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                                                    list: List<R>;
+                                                    tookMs: number;
+                                                }>;
+                                            };
+                                            /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                                             * scope. Orders count once each, however often they're sent. */
+                                            events: {
+                                                /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                                                 * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                                                send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                                                /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                                                 * cursor), 200 a request. */
+                                                importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                                                /** Takes a cancelled or refunded order out of Bought together. */
+                                                cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                                                /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                                                 * within a week. 1,000 IDs a request. */
+                                                forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                                                    forgotten: number;
+                                                }>;
+                                                /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                                                 * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                                                 * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                                                 * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                                                 * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                                                proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                                                /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                                                 * and its visitor. Answers with the API's response. */
+                                                relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                                            };
+                                            /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                                             * requests from web pages are refused. */
+                                            analytics: {
+                                                /** Searches, searches without results and response times, beside the same span before, and a series per
+                                                 * hour (up to 7 days, by default) or day. */
+                                                searches: (options?: AnalyticsOptions & {
+                                                    interval?: "hour" | "day";
+                                                }) => Promise<SearchesReport>;
+                                                /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                                                 * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                                                queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                                                    list?: L | undefined;
+                                                    limit?: number;
+                                                }) => Promise<QueriesReport<L>>;
+                                                /** The filter fields and sorts searches used. */
+                                                filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                                                /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                                                events: (options?: AnalyticsOptions & {
+                                                    interval?: "hour" | "day";
+                                                }) => Promise<EventsReport>;
+                                                /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                                                 * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                                                products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                                                /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                                                 * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                                                productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                                                /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                                                 * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                                                 * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                                                product: (objectID: string, options?: AnalyticsOptions & {
+                                                    interval?: "hour" | "day";
+                                                }) => Promise<ProductReport>;
+                                                /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                                                 * product (0.20.0). */
+                                                revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                                                /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                                                 * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                                                banners: (options?: {
+                                                    range?: "7d" | "30d" | "90d";
+                                                    signal?: AbortSignal;
+                                                }) => Promise<BannerStatsReport>;
+                                            };
+                                            upsert: (records: S_8[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                            getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_8>>;
+                                            upsertOne: (record: S_8, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                            deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                            replaceAll: (records: S_8[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                            beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                            uploadReplacementBatch: (stageId: string, batchId: string, records: S_8[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                                            commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                            abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                            replaceAllStaged: (records: Iterable<S_8> | AsyncIterable<S_8>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                                            delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                            getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                                            replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                                            /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                                             * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                                             * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                                             * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                                             * or normalization) throws a 409: save it first. Not counted as searches. */
+                                            compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                                            /** The index's search tests. */
+                                            getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                                            /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                                            setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                                            /** Waits until no settings rebuild is running; throws if it failed. */
+                                            waitForSettings: (options?: {
+                                                timeoutMs?: number;
+                                                intervalMs?: number;
+                                                signal?: AbortSignal;
+                                            }) => Promise<CurrentSettings>;
+                                            subindex: <S_9 extends {
+                                                objectID: string;
+                                            } = JsonRecord>(subindex: string) => {
+                                                /** Searches the index; the API key needs the `search` scope. Pass `{ visitor }` when searching for
+                                                 * someone, such as a shopper loading a server-rendered page (see Visitor). */
+                                                search: <R = S_9>(query?: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<SearchResponse<R>>;
+                                                /** Did you mean: for a search that found nothing, a query that finds something, or null. Takes the
+                                                 * same request (its q, filters, and fields matter). Needs the `didYouMean` setting; not counted as
+                                                 * a search. */
+                                                suggest: (query: SearchRequest, options?: AbortSignal | RequestOptions) => Promise<DidYouMean | null>;
+                                                /** Query suggestions: whole searches to offer as a shopper types `q`, the best first; with `q` empty, the
+                                                 * index's popular searches. The API key needs the `search` scope; not counted as searches. `limit`: 1 to
+                                                 * 10, 5 by default. */
+                                                querySuggestions: (query: {
+                                                    q: string;
+                                                    limit?: number;
+                                                }, options?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                                /** The index's popular searches, for an empty search box, with the owner's pinned searches first;
+                                                 * empty until the index has enough searches. The list changes daily. */
+                                                popularSearches: (options?: {
+                                                    limit?: number;
+                                                }, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<QuerySuggestion[]>;
+                                                /** A product's recommendations (the recommendations add-on): products that go with it, and similar products.
+                                                 * The API key needs the `search` scope; not counted as a search. */
+                                                recommendations: <R = S_9>(objectID: string, options?: RecommendationsRequest, requestOptionsOrSignal?: AbortSignal | RequestOptions) => Promise<RecommendationsResponse<R>>;
+                                                /** The index's lists: rows of products, such as Popular, and facet fields' values for menus, built ahead
+                                                 * and served from a cache, so reading them isn't counted as searches. Reading needs the `search` scope;
+                                                 * setting them up needs `write`. */
+                                                /** Merchandising (0.23.0): category pages and searches arranged as the dashboard's Merchandising page does:
+                                                 * the products placed first, hidden products, a banner, and when. Saved as the page's rule within seconds,
+                                                 * keeping anything else the rule does. Reading needs the `search` or `write` scope; changing, `write`. */
+                                                merchandising: {
+                                                    /** Every arranged category page and search. */
+                                                    list: (signal?: AbortSignal) => Promise<Arrangement[]>;
+                                                    /** One page's or search's arrangement; status "none" when nothing is arranged. */
+                                                    get: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                                    /** Changes one: `order` up to 20 objectIDs placed first, `hidden` up to 100, `banner` ({ image, link?, title?,
+                                                     * position? } or null), `active` ({ from?, until? } or null), `enabled`. Fields left out stay as they are. */
+                                                    set: (target: MerchandisingTarget, change: ArrangementChange, signal?: AbortSignal) => Promise<Arrangement>;
+                                                    /** Stops arranging one: its order, hidden products and banner go; the rule's other actions stay. */
+                                                    remove: (target: MerchandisingTarget, signal?: AbortSignal) => Promise<Arrangement>;
+                                                };
+                                                /** Images for the index's banners, hosted by Findlane at https://images.findlane.dev (0.23.0): JPEG, PNG,
+                                                 * WebP or AVIF, up to 2 MB each, 50 images and 100 MB an index. An image no rule shows is deleted a week
+                                                 * later. Uploading and deleting need the `write` scope. */
+                                                images: {
+                                                    list: (signal?: AbortSignal) => Promise<ImageLibrary>;
+                                                    /** Uploads an image's bytes; the same image again gives the same URL. */
+                                                    upload: (image: Blob | ArrayBuffer | Uint8Array, options?: {
+                                                        contentType?: string;
+                                                        signal?: AbortSignal;
+                                                    }) => Promise<UploadedImage & {
+                                                        error?: string;
+                                                    }>;
+                                                    /** Uploads the image at an https address, which Findlane fetches. */
+                                                    uploadFromUrl: (url: string, signal?: AbortSignal) => Promise<UploadedImage>;
+                                                    /** Deletes an image by its key; refused (409) while a rule's banner shows it. */
+                                                    delete: (key: string, signal?: AbortSignal) => Promise<{
+                                                        deleted: true;
+                                                    }>;
+                                                };
+                                                /** The index's product feed (0.24.0): a store's Google or Meta product feed, or a JSON file of records, read on
+                                                 * a schedule (hourly, every 6 hours, or daily), replacing the index's records with only what changed. Reading
+                                                 * needs the `search` or `write` scope; the rest, `write`. */
+                                                feed: {
+                                                    /** The feed and its last run, or null. */
+                                                    get: (signal?: AbortSignal) => Promise<ProductFeed | null>;
+                                                    /** Connects a feed or changes its setup; a new address, sign-in or variants setting reads it now. */
+                                                    set: (setup: FeedSetup, signal?: AbortSignal) => Promise<ProductFeed>;
+                                                    /** Disconnects it; the index keeps its records. */
+                                                    remove: (signal?: AbortSignal) => Promise<void>;
+                                                    /** Reads a feed's first 2,000 items without saving anything; without a url, the connected feed's. */
+                                                    check: (setup?: Pick<FeedSetup, "url" | "username" | "password" | "variants">, signal?: AbortSignal) => Promise<FeedCheck>;
+                                                    /** Reads it now, in full, in the background; `runs` shows how it went. */
+                                                    run: (signal?: AbortSignal) => Promise<FeedRun>;
+                                                    /** The last 20 runs, newest first. */
+                                                    runs: (signal?: AbortSignal) => Promise<FeedRun[]>;
+                                                    /** Imports a held run's copy of the feed as it is, without the checks that held it. */
+                                                    importHeld: (runId: string, signal?: AbortSignal) => Promise<FeedRun>;
+                                                };
+                                                lists: {
+                                                    /** One list by its ID; throws a FindlaneError with status 404 when there's none. `limit` shows fewer. */
+                                                    get: <R = S_9>(id: string, options?: {
+                                                        limit?: number;
+                                                        signal?: AbortSignal;
+                                                    }) => Promise<List<R>>;
+                                                    /** Several lists (up to 10) in the order asked, leaving out IDs without a list; without IDs, all of them. */
+                                                    getMany: <R = S_9>(ids?: string[], options?: {
+                                                        limit?: number;
+                                                        signal?: AbortSignal;
+                                                    }) => Promise<List<R>[]>;
+                                                    /** How the index's lists are set up, and their last build. */
+                                                    settings: (signal?: AbortSignal) => Promise<ListSettings>;
+                                                    /** Creates or changes a list and builds it; one whose filters, sort or field don't work on the index is
+                                                     * refused with why (400), and a new list past the plan's lists per index too (402). */
+                                                    save: (id: string, list: ListDefinition, signal?: AbortSignal) => Promise<ListSettings>;
+                                                    delete: (id: string, signal?: AbortSignal) => Promise<ListSettings>;
+                                                    /** Puts the lists in this order: every list's ID once. */
+                                                    order: (ids: string[], signal?: AbortSignal) => Promise<ListSettings>;
+                                                    /** Builds the lists again now, rather than within the minute they take to follow the index; once a minute. */
+                                                    refresh: (signal?: AbortSignal) => Promise<ListSettings>;
+                                                    /** What a list would hold, built without saving it. */
+                                                    preview: <R = S_9>(list: ListDefinition, signal?: AbortSignal) => Promise<{
+                                                        list: List<R>;
+                                                        tookMs: number;
+                                                    }>;
+                                                };
+                                                /** Events for the index's Events page and Bought together; the API key needs the `events` or `write`
+                                                 * scope. Orders count once each, however often they're sent. */
+                                                events: {
+                                                    /** Sends events, 200 a request. One bad event doesn't refuse the rest: they're in `rejected`. Pass
+                                                     * `{ visitorId, visitId }` to link a shopper's events (see EventOptions). */
+                                                    send: (events: ServerEvent[], options?: AbortSignal | EventOptions) => Promise<EventsResult>;
+                                                    /** Sends past orders, up to 400 days old, from a list or an async iterable (such as a database
+                                                     * cursor), 200 a request. */
+                                                    importOrders: (orders: Iterable<Order> | AsyncIterable<Order>, signal?: AbortSignal) => Promise<EventsResult>;
+                                                    /** Takes a cancelled or refunded order out of Bought together. */
+                                                    cancelOrder: (orderID: string, signal?: AbortSignal) => Promise<EventsResult>;
+                                                    /** Deletes the events sent with these visitor or visit IDs, for shoppers who asked: Findlane does it
+                                                     * within a week. 1,000 IDs a request. */
+                                                    forget: (ids: string[], signal?: AbortSignal) => Promise<{
+                                                        forgotten: number;
+                                                    }>;
+                                                    /** A route on your own domain for the browser SDK's events (its `eventsUrl` option): ad blockers
+                                                     * block beacons to other sites, not to the page's own. Give it the browser's POST request (Next.js
+                                                     * route handlers, Workers, Hono, Bun, Deno); it finds the visitor's address in the headers
+                                                     * Cloudflare, Vercel and most proxies set. Where a visitor reaches your server directly, they can
+                                                     * set those too, so pass `{ ip }`. The API key needs the `events` or `write` scope. */
+                                                    proxy: (request: Request, visitor?: Partial<RelayedVisitor>) => Promise<Response>;
+                                                    /** `proxy` for servers without Fetch API requests, such as Express: the request's body as text,
+                                                     * and its visitor. Answers with the API's response. */
+                                                    relay: (body: string, visitor: RelayedVisitor, signal?: AbortSignal) => Promise<Response>;
+                                                };
+                                                /** The index's search analytics. The API key needs the `analytics` scope, and works only from a server:
+                                                 * requests from web pages are refused. */
+                                                analytics: {
+                                                    /** Searches, searches without results and response times, beside the same span before, and a series per
+                                                     * hour (up to 7 days, by default) or day. */
+                                                    searches: (options?: AnalyticsOptions & {
+                                                        interval?: "hour" | "day";
+                                                    }) => Promise<SearchesReport>;
+                                                    /** Queries, the most searched first: `top` (by default) with their clicks, `noResults`, or `noClicks`, which
+                                                     * found something nobody clicked. `limit` is 1 to 1,000, 100 by default. */
+                                                    queries: <L extends keyof QueryLists = "top">(options?: AnalyticsOptions & {
+                                                        list?: L | undefined;
+                                                        limit?: number;
+                                                    }) => Promise<QueriesReport<L>>;
+                                                    /** The filter fields and sorts searches used. */
+                                                    filters: (options?: AnalyticsOptions) => Promise<FiltersReport>;
+                                                    /** Events of each type over time and by source, orders stored, and refused and bot events. */
+                                                    events: (options?: AnalyticsOptions & {
+                                                        interval?: "hour" | "day";
+                                                    }) => Promise<EventsReport>;
+                                                    /** The most viewed, most added to carts and most ordered products, with titles and images, and those
+                                                     * viewed but rarely bought. Exact, from every event kept (13 months, from 9 October 2026). */
+                                                    products: (options?: AnalyticsOptions) => Promise<ProductListsReport>;
+                                                    /** Every product with events or orders in the window, the most viewed first, up to 50,000: views,
+                                                     * viewers, clicks, add-to-carts and orders. Exact, like `products`. */
+                                                    productCounts: (options?: AnalyticsOptions) => Promise<ProductCountsReport>;
+                                                    /** One product's views, viewers, clicks, add-to-carts and orders per hour or day, the queries it was
+                                                     * clicked from, and its clicks in recommendations. Fast, for a product page in an admin: views and
+                                                     * clicks are estimates when `sampled`, and an add-to-cart of several products counts toward the first. */
+                                                    product: (objectID: string, options?: AnalyticsOptions & {
+                                                        interval?: "hour" | "day";
+                                                    }) => Promise<ProductReport>;
+                                                    /** Revenue from search: orders and add-to-carts of products found through search, per query and per
+                                                     * product (0.20.0). */
+                                                    revenue: (options?: Omit<AnalyticsOptions, "source">) => Promise<RevenueReport>;
+                                                    /** Each banner's shown (shoppers' searches that showed it, cache answers included) and clicks, by its rule,
+                                                     * over the last 7, 30 (by default) or 90 days (0.23.0). */
+                                                    banners: (options?: {
+                                                        range?: "7d" | "30d" | "90d";
+                                                        signal?: AbortSignal;
+                                                    }) => Promise<BannerStatsReport>;
+                                                };
+                                                upsert: (records: S_9[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                                getRecord: (objectID: string, signal?: AbortSignal) => Promise<RecordSnapshot<S_9>>;
+                                                upsertOne: (record: S_9, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                                deleteOne: (objectID: string, options: ConditionalWriteOptions) => Promise<WriteReceipt>;
+                                                replaceAll: (records: S_9[], signal?: AbortSignal) => Promise<WriteReceipt>;
+                                                beginReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                                uploadReplacementBatch: (stageId: string, batchId: string, records: S_9[], signal?: AbortSignal) => Promise<ReplacementStage>;
+                                                commitReplacement: (stageId: string, expectedBatches: number, expectedRecords: number, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                                abortReplacement: (stageId: string, signal?: AbortSignal) => Promise<ReplacementStage>;
+                                                replaceAllStaged: (records: Iterable<S_9> | AsyncIterable<S_9>, options?: StagedReplaceOptions) => Promise<WriteReceipt>;
+                                                delete: (objectID: string, signal?: AbortSignal) => Promise<WriteReceipt>;
+                                                getSettings: (signal?: AbortSignal) => Promise<CurrentSettings>;
+                                                replaceSettings: (settings: IndexSettings, signal?: AbortSignal) => Promise<SavedSettings>;
+                                                /** Compares settings with the index's own without saving them: its search tests, `queries`, and its 100
+                                                 * most searched queries of the last 30 days, each searched with both, for up to 20 seconds. Takes the
+                                                 * settings `replaceSettings` does, or only those that change; `{}` runs the tests with the current
+                                                 * settings. A change to what the index stores (new searchable, facet, filter, sort or location fields,
+                                                 * or normalization) throws a 409: save it first. Not counted as searches. */
+                                                compareSettings: (settings: Partial<IndexSettings>, options?: CompareOptions) => Promise<SettingsComparison>;
+                                                /** The index's search tests. */
+                                                getSearchTests: (signal?: AbortSignal) => Promise<SearchTest[]>;
+                                                /** Replaces the index's search tests, up to 200; `[]` deletes them. */
+                                                setSearchTests: (tests: SearchTest[], signal?: AbortSignal) => Promise<SearchTest[]>;
+                                                /** Waits until no settings rebuild is running; throws if it failed. */
+                                                waitForSettings: (options?: {
+                                                    timeoutMs?: number;
+                                                    intervalMs?: number;
+                                                    signal?: AbortSignal;
+                                                }) => Promise<CurrentSettings>;
+                                                subindex: <S_10 extends {
+                                                    objectID: string;
+                                                } = JsonRecord>(subindex: string) => /*elided*/ any;
+                                                /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                                                listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                                                getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                                setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                                usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                                getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                                                waitUntilIndexed: (revision: number, options?: {
+                                                    timeoutMs?: number;
+                                                    intervalMs?: number;
+                                                    signal?: AbortSignal;
+                                                }) => Promise<IndexingStatus>;
+                                            };
+                                            /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                                            listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                                            getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                            setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                            usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                            getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                                            waitUntilIndexed: (revision: number, options?: {
+                                                timeoutMs?: number;
+                                                intervalMs?: number;
+                                                signal?: AbortSignal;
+                                            }) => Promise<IndexingStatus>;
+                                        };
+                                        /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                                        listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                                        getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                        setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                        usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                        getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                                        waitUntilIndexed: (revision: number, options?: {
+                                            timeoutMs?: number;
+                                            intervalMs?: number;
+                                            signal?: AbortSignal;
+                                        }) => Promise<IndexingStatus>;
+                                    };
+                                    /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                                    listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                                    getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                    setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                    usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                    getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                                    waitUntilIndexed: (revision: number, options?: {
+                                        timeoutMs?: number;
+                                        intervalMs?: number;
+                                        signal?: AbortSignal;
+                                    }) => Promise<IndexingStatus>;
+                                };
+                                /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                                listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                                getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                                getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                                waitUntilIndexed: (revision: number, options?: {
+                                    timeoutMs?: number;
+                                    intervalMs?: number;
+                                    signal?: AbortSignal;
+                                }) => Promise<IndexingStatus>;
+                            };
+                            /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                            listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                            getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                            setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                            usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                            getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                            waitUntilIndexed: (revision: number, options?: {
+                                timeoutMs?: number;
+                                intervalMs?: number;
+                                signal?: AbortSignal;
+                            }) => Promise<IndexingStatus>;
+                        };
+                        /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                        listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                        getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                        setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                        usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                        getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                        waitUntilIndexed: (revision: number, options?: {
+                            timeoutMs?: number;
+                            intervalMs?: number;
+                            signal?: AbortSignal;
+                        }) => Promise<IndexingStatus>;
+                    };
+                    /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                    listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                    getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                    setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                    usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                    getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                    waitUntilIndexed: (revision: number, options?: {
+                        timeoutMs?: number;
+                        intervalMs?: number;
+                        signal?: AbortSignal;
+                    }) => Promise<IndexingStatus>;
+                };
+                /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+                listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+                getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+                getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+                waitUntilIndexed: (revision: number, options?: {
+                    timeoutMs?: number;
+                    intervalMs?: number;
+                    signal?: AbortSignal;
+                }) => Promise<IndexingStatus>;
+            };
+            /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+            listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
+            getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+            setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
+            usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
+            getIndexingStatus: (signal?: AbortSignal) => Promise<IndexingStatus>;
+            waitUntilIndexed: (revision: number, options?: {
+                timeoutMs?: number;
+                intervalMs?: number;
+                signal?: AbortSignal;
+            }) => Promise<IndexingStatus>;
+        };
+        /** The index's subindexes, with their records (0.25.0). Owners make them in the dashboard. */
+        listSubindexes: (signal?: AbortSignal) => Promise<Subindex[]>;
         getPublicSearchAccess: (signal?: AbortSignal) => Promise<PublicSearchAccess>;
         setPublicSearchPolicy: (policy: PublicSearchPolicy, signal?: AbortSignal) => Promise<PublicSearchAccess>;
         usePublicIndexDefaults: (signal?: AbortSignal) => Promise<PublicSearchAccess>;