@cosmoops/connect-sdk 0.9.0 → 0.16.0

package/dist/types/server/client.d.ts

@@ -2,6 +2,9 @@ import type { FetchLike } from "./http.js";
 import { AccessResource } from "./resources/access.js";
 import { AppsResource } from "./resources/apps.js";
 import { AiResource } from "./resources/ai.js";
+import { DataResource } from "./resources/data.js";
+import { WorkspacesResource } from "./resources/workspaces.js";
+import { KvResource } from "./resources/kv.js";
 import { BillingResource } from "./resources/billing.js";
 import { DriveResource } from "./resources/drive.js";
 import { EntitlementsResource } from "./resources/entitlements.js";
@@ -11,10 +14,11 @@ import { LogsResource } from "./resources/logs.js";
 import { AnalyticsResource } from "./resources/analytics.js";
 import { OtpResource } from "./resources/otp.js";
 import { SessionsResource } from "./resources/sessions.js";
+import { PlatformResource } from "./resources/platform.js";
 export declare const DEFAULT_BASE_URL = "https://connect.cosmoops.com";
 export interface ConnectClientOptions {
     /**
-     * The API key plaintext from this application's Integration tab, shown once at
+     * The API key plaintext from this application's Connect client section, shown once at
      * creation.
      *
      * One credential does three jobs: it is the `Authorization: Bearer` value
@@ -73,6 +77,10 @@ export declare class ConnectClient {
     readonly drive: DriveResource;
     /** RAG chat and structured extraction. */
     readonly ai: AiResource;
+    /** Your application's own document store - see `DataResource`. */
+    readonly data: DataResource;
+    /** Your application's key/value store - see `KvResource`. */
+    readonly kv: KvResource;
     /** WhatsApp/SMS phone verification. */
     readonly otp: OtpResource;
     /** Feature events into the Console's audit log, filterable to your application. */
@@ -83,7 +91,22 @@ export declare class ConnectClient {
     readonly sessions: SessionsResource;
     /** Composio-hosted third-party connections (Google Calendar, Slack, ...) a workspace has connected. */
     readonly integrations: IntegrationsResource;
+    /** Which workspaces the signed-in user belongs to, switching between them, and the team - see `WorkspacesResource`. */
+    readonly workspaces: WorkspacesResource;
+    /** The platform's own legal identity and DPDP grievance channel - see `PlatformResource`. */
+    readonly platform: PlatformResource;
+    /**
+     * Relays one `/data/*` or `/kv/*` request verbatim - `createConnectHandler`'s
+     * store route and nothing else. See `storePassthrough`.
+     * @internal
+     */
+    readonly storeRelay: (spec: {
+        method: "GET" | "POST" | "PUT" | "DELETE";
+        path: string;
+        json?: unknown;
+        headers?: Record<string, string>;
+    }) => Promise<Response>;
     constructor(options: ConnectClientOptions);
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export declare const SDK_VERSION = "0.9.0";
+export declare const SDK_VERSION = "0.16.0";

package/dist/types/server/http.d.ts

@@ -1,6 +1,11 @@
 export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
 export interface RequestSpec {
-    method: "GET" | "POST";
+    /**
+     * `PUT` and `DELETE` were added for the store resources. Both are idempotent
+     * by HTTP's own definition, so both are retried like `GET` - see the retry
+     * note on `request`.
+     */
+    method: "GET" | "POST" | "PUT" | "DELETE";
     /** Relative to the API base, e.g. `/plans`. */
     path: string;
     query?: Record<string, string | number | undefined>;
@@ -49,7 +54,8 @@ export declare function pathSegment(value: string, name: string): string;
  * `ConnectError`.
  *
  * **On retries.** Only idempotent requests are retried without a caller
- * opt-in: every `GET`, plus any `POST` carrying an `Idempotency-Key` (the
+ * opt-in: every `GET`, `PUT` and `DELETE`, plus any `POST` carrying an
+ * `Idempotency-Key` (the
  * resources that mutate - `billing.consumeAddon`, `otp.send` - always set
  * one). A bare `POST` is attempted exactly once, because a 429 or a 504 says
  * nothing about whether the server already did the work.

package/dist/types/server/index.d.ts

@@ -18,11 +18,15 @@ export type { AppsResource } from "./resources/apps.js";
 export type { EntitlementsResource } from "./resources/entitlements.js";
 export type { BillingResource } from "./resources/billing.js";
 export type { AiResource } from "./resources/ai.js";
+export type { DataResource } from "./resources/data.js";
+export type { KvResource } from "./resources/kv.js";
+export type { WorkspacesResource } from "./resources/workspaces.js";
 export type { OtpResource } from "./resources/otp.js";
 export type { LogsResource } from "./resources/logs.js";
 export type { AnalyticsResource } from "./resources/analytics.js";
 export type { SessionsResource } from "./resources/sessions.js";
 export type { ExecuteIntegrationActionInput, IntegrationsResource } from "./resources/integrations.js";
+export type { PlatformResource } from "./resources/platform.js";
 /**
  * Webhook verification and a ready-made POST route. Server-only for the
  * obvious reason: the signing secret must never reach a browser bundle.

package/dist/types/server/resources/acting-as.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The header that turns a server-to-server store call into one made *on behalf
+ * of* a signed-in user.
+ *
+ * Connect resolves the token to a user and a workspace itself and checks the
+ * collection's declared permission against that member's live roles - so a
+ * caller supplying this is asking for a *narrower* check than an application
+ * call, never a wider one. An unresolvable token is refused rather than
+ * quietly downgraded, precisely because the downgrade would be an escalation.
+ */
+export declare function actingAs(sessionToken: string | undefined): Record<string, string>;

package/dist/types/server/resources/ai.d.ts

@@ -1,6 +1,13 @@
 import { type TransportOptions } from "../http.js";
-import type { ChatMessage } from "../../types.js";
-/** RAG chat and structured extraction against a workspace's data. */
+import type { ChatMessage, ConnectScreen } from "../../types.js";
+/**
+ * RAG chat and structured extraction against a workspace's data.
+ *
+ * `asUser` on `chat` behaves as it does on the store resources: pass a
+ * signed-in user's `sessionToken` and Connect resolves the workspace from it,
+ * ignoring `workspaceId`. Without it you are the application, naming the
+ * workspace yourself.
+ */
 export declare class AiResource {
     private readonly transport;
     constructor(transport: TransportOptions);
@@ -13,6 +20,17 @@ export declare class AiResource {
     chat(input: {
         workspaceId: string;
         messages: ChatMessage[];
+        asUser?: string;
+        /**
+         * Your application's screens, so the assistant answers in your product's
+         * words and can link into it - see `ConnectScreen`. Prose and links only:
+         * Connect never uses these to decide what anyone may do.
+         */
+        screens?: readonly ConnectScreen[] | unknown;
+        /** Where the user is, as `{ pathname }`. Matched against `screens`. */
+        screenContext?: {
+            pathname?: string;
+        } | unknown;
     }, options?: {
         signal?: AbortSignal;
     }): Promise<Response>;

package/dist/types/server/resources/data.d.ts

@@ -0,0 +1,258 @@
+import { type TransportOptions } from "../http.js";
+import type { StoreAggregatePage, StoreAggregation, StoreCommitOperation, StoreCommitResult, StoreDocument, StoreQueryFilter, StoreQueryPage, StoreOrderBy, StoreScanPage } from "../../types.js";
+/**
+ * Your application's own document store - a dedicated Firestore database that
+ * only Connect can reach.
+ *
+ * You hold no Firebase credential and write no security rules. Collections are
+ * declared in the Console; an undeclared name is refused rather than created,
+ * and `workspaceId` is a path segment rather than a filter, so a query cannot
+ * cross tenants.
+ *
+ * **A query needs an index for its shape, and there are two ways to have one.**
+ * Firestore maintains a single-field index automatically, which covers one
+ * filter, or an `orderBy` on that same field. Anything wider - two filters, or
+ * a filter ordered by a different field - needs a composite index **declared
+ * on your application's Store tab**, which Connect then builds in your
+ * database. A query with no matching index is refused up front, naming the
+ * index to declare, rather than failing later with a Firestore index error
+ * pointing at a console you cannot open.
+ *
+ * **Dates are ISO-8601 strings.** The store writes what you send it, and JSON
+ * has no date type, so a `Date` must be sent as `toISOString()`. That is not a
+ * compromise: UTC ISO strings sort lexicographically in chronological order,
+ * so ordering and range filters on them behave exactly as they would on a
+ * timestamp - and Connect's own `_createdAt`/`_updatedAt` come back in the
+ * same form.
+ *
+ * **`workspaceId` is omitted for master data.** A collection declared
+ * application-scoped in the Console belongs to no workspace - one copy, owned
+ * by you, read by every tenant. Those are written with your API key only,
+ * never on behalf of a user: a write permission is something a *workspace*
+ * grants, so honouring one on shared data would give one tenant's admin reach
+ * over every other tenant's reference data.
+ *
+ * **`asUser` is how you act on behalf of a signed-in user.** Pass the opaque
+ * `sessionToken` you were given at sign-in and Connect resolves the user and
+ * their workspace from it - checking the collection's declared permission
+ * against what that member actually holds, and **ignoring `workspaceId`
+ * entirely**. Without it you are the application itself: your API key's scopes
+ * are the only gate, and the per-user permissions do not apply. The bridge
+ * (`createConnectHandler`) always passes it, which is what makes the browser
+ * path safe.
+ */
+export declare class DataResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /** Reads one document. Throws `ConnectError` with status 404 when it does not exist. */
+    get(input: {
+        workspaceId?: string;
+        collection: string;
+        id: string;
+        asUser?: string;
+    }): Promise<StoreDocument>;
+    /**
+     * Lists a collection, one page at a time.
+     *
+     * `filters` are ANDed. More than one, or one combined with an `orderBy` on a
+     * different field, needs a composite index declared on the Store tab - see
+     * the class note above.
+     *
+     * `limit` defaults to 50 and caps at 200. Page by passing the previous
+     * page's `nextCursor`; a `null` `nextCursor` is the end of the collection.
+     */
+    query(input: {
+        workspaceId?: string;
+        collection: string;
+        filters?: StoreQueryFilter[];
+        orderBy?: StoreOrderBy;
+        limit?: number;
+        cursor?: string | null;
+        asUser?: string;
+    }): Promise<StoreQueryPage>;
+    /**
+     * Counts, sums and averages a filtered collection - **in Firestore**, not by
+     * reading the rows back and adding them up.
+     *
+     * That distinction is the whole point. An aggregation is billed by the index
+     * entries it scans rather than by the documents it would have returned, so a
+     * dashboard tile over ten thousand rows costs a handful of reads and stays
+     * flat as the collection grows. Paging the rows into your own process to sum
+     * them is an unbounded read, and it is what every integration does when
+     * there is no aggregate call to reach for.
+     *
+     * ```ts
+     * const { values } = await connect.data.aggregate({
+     *   workspaceId,
+     *   collection: "deals",
+     *   filters: [{ field: "outcome", op: "==", value: "won" }],
+     *   aggregations: [
+     *     { op: "count", alias: "count" },
+     *     { op: "sum", field: "value", alias: "total" },
+     *   ],
+     * });
+     * ```
+     *
+     * A `sum` or `avg` over nothing answers `null` rather than `0`, because
+     * "nothing matched" and "the total is zero" are different facts.
+     *
+     * The index it needs is the one its **filters** need plus the aggregated
+     * field - Firestore reads a sum out of the index rather than out of the
+     * documents.
+     *
+     * There is no `orderBy`, `limit` or `cursor`: the aggregate of an ordered
+     * page is the aggregate of the whole filtered set.
+     */
+    aggregate(input: {
+        workspaceId?: string;
+        collection: string;
+        aggregations: StoreAggregation[];
+        filters?: StoreQueryFilter[];
+        asUser?: string;
+    }): Promise<StoreAggregatePage>;
+    /**
+     * Reads one collection across **every workspace at once** - your own
+     * back-office view of your whole customer base. Each row carries the
+     * `workspaceId` it came from.
+     *
+     * Needs the `data:read:all` scope, and the collection must be marked
+     * cross-workspace in the Console. There is deliberately **no `asUser`**: a
+     * scan is never available on behalf of a signed-in user, because a workspace
+     * admin is an admin of their own workspace and not of your other customers.
+     *
+     * Filtering and ordering follow the same index rules as `query`, and
+     * additionally need collection-group scope. Connect creates those from the
+     * declaration - the single-field ones when you mark a field queryable, and a
+     * group-scoped copy of every composite index the collection declares. A scan
+     * issued in the minutes after that declaration may fail while the index
+     * builds.
+     */
+    scan(input: {
+        collection: string;
+        filters?: StoreQueryFilter[];
+        orderBy?: StoreOrderBy;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<StoreScanPage>;
+    /**
+     * Creates a document. Pass `id` to choose it, or omit it and one is
+     * allocated. An `id` that already exists throws with status 409 - use
+     * `replace` to overwrite deliberately.
+     */
+    create(input: {
+        workspaceId?: string;
+        collection: string;
+        data: Record<string, unknown>;
+        id?: string;
+        asUser?: string;
+    }): Promise<StoreDocument>;
+    /** Replaces every field, creating the document if it does not exist. `_createdAt`/`_createdBy` survive. */
+    replace(input: {
+        workspaceId?: string;
+        collection: string;
+        id: string;
+        data: Record<string, unknown>;
+        asUser?: string;
+    }): Promise<StoreDocument>;
+    /** Merges top-level fields into an existing document. Throws with status 404 if it does not exist. */
+    update(input: {
+        workspaceId?: string;
+        collection: string;
+        id: string;
+        data: Record<string, unknown>;
+        asUser?: string;
+    }): Promise<StoreDocument>;
+    /** Idempotent - deleting a document that is not there succeeds. */
+    delete(input: {
+        workspaceId?: string;
+        collection: string;
+        id: string;
+        asUser?: string;
+    }): Promise<void>;
+    /**
+     * Applies a set of writes atomically, across as many of your collections as
+     * they name. All of them land, or none.
+     *
+     * This is the store's answer to a database transaction, and the shape is
+     * deliberate: **you never hold one**. A transaction handle passed across an
+     * HTTP boundary is a server-side lock whose duration your network controls,
+     * with Firestore's sixty-second ceiling and lock contention as the failure
+     * mode. Instead you read, decide, and commit *conditional on nothing having
+     * moved* - Connect runs the whole set as one short transaction on its side.
+     *
+     * ```ts
+     * await connect.data.commit({
+     *   workspaceId,
+     *   operations: [
+     *     { op: "create", collection: "ledger", id, data: entry },
+     *     {
+     *       op: "merge",
+     *       collection: "funds",
+     *       id: entry.fundId,
+     *       data: { balancePaise: increment(entry.amountPaise) },
+     *     },
+     *   ],
+     * });
+     * ```
+     *
+     * A precondition that no longer holds throws `ConnectError` with status 409
+     * and **writes nothing** - see `transaction`, which re-reads and retries for
+     * you. Note that the example above needs no precondition at all: an
+     * `increment` is commutative, so concurrent commits both land correctly.
+     *
+     * Returns the id each operation wrote, in order - which is how you learn the
+     * id a `create` without one was given.
+     */
+    commit(input: {
+        workspaceId?: string;
+        operations: StoreCommitOperation[];
+        asUser?: string;
+    }): Promise<StoreCommitResult>;
+    /**
+     * Read, decide, commit - retried when the world moved underneath you.
+     *
+     * The optimistic-concurrency loop, written once. `build` reads whatever it
+     * needs and returns the operations to apply; if any precondition among them
+     * has gone stale by the time Connect looks, the commit is rejected whole and
+     * `build` runs again against fresh reads.
+     *
+     * ```ts
+     * await connect.data.transaction(async () => {
+     *   const fund = await connect.data.get({ workspaceId, collection: "funds", id });
+     *   if (!fund.data.active) throw new Error("That fund is closed.");
+     *   return [
+     *     {
+     *       op: "merge",
+     *       collection: "funds",
+     *       id,
+     *       data: { balancePaise: increment(amount) },
+     *       precondition: unchangedSince(fund),
+     *     },
+     *   ];
+     * });
+     * ```
+     *
+     * **Only a 409 is retried.** A 403 or a validation error means the operation
+     * was wrong rather than late, and retrying it would turn one clear failure
+     * into `attempts` identical ones. An error thrown by `build` itself - the
+     * closed-fund check above - is not retried either: it is a decision, not a
+     * collision.
+     *
+     * `build` must be free of side effects outside the returned operations,
+     * because it can run more than once. That is the price of not holding a
+     * lock, and it is the same contract Firestore's own `runTransaction` states
+     * for the same reason.
+     */
+    transaction(build: () => Promise<StoreCommitOperation[]>, options?: {
+        workspaceId?: string;
+        asUser?: string;
+        attempts?: number;
+    }): Promise<StoreCommitResult>;
+    private write;
+}
+export declare function storePassthrough(transport: TransportOptions, spec: {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    path: string;
+    json?: unknown;
+    headers?: Record<string, string>;
+}): Promise<Response>;

package/dist/types/server/resources/kv.d.ts

@@ -0,0 +1,63 @@
+import { type TransportOptions } from "../http.js";
+import type { KvEntry, KvPage } from "../../types.js";
+/**
+ * Your application's key/value store - small values addressed by namespace and
+ * key, per workspace.
+ *
+ * Use it for what a document store is bad at: a feature flag, a cached
+ * computation, a counter, a draft nobody needs to query. Anything you want to
+ * *find* rather than *fetch* belongs in `data`.
+ *
+ * Namespaces are declared in the Console exactly like collections. Keys are
+ * `[A-Za-z0-9_-]` up to 64 characters, and values are JSON up to 128 KB.
+ *
+ * `asUser` behaves exactly as it does on `DataResource` - pass a signed-in
+ * user's `sessionToken` and Connect derives the user and workspace from it,
+ * checking the namespace's declared permission against their live roles.
+ */
+export declare class KvResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /**
+     * Reads one key. Throws `ConnectError` with status 404 when the key is
+     * absent **or expired** - expiry is evaluated on read, so there is no window
+     * where a stale value is still served.
+     */
+    get(input: {
+        workspaceId?: string;
+        namespace: string;
+        key: string;
+        asUser?: string;
+    }): Promise<KvEntry>;
+    /**
+     * Pages a namespace in key order.
+     *
+     * Expired entries are filtered out after paging, so a page can come back
+     * shorter than `limit` while still having a `nextCursor` - treat
+     * `nextCursor` as the only signal that more keys exist, never an empty page.
+     */
+    list(input: {
+        workspaceId?: string;
+        namespace: string;
+        limit?: number;
+        cursor?: string | null;
+        asUser?: string;
+    }): Promise<KvPage>;
+    /** Sets a value, replacing whatever was there. `ttlSeconds` expires it; omit for no expiry. */
+    set(input: {
+        workspaceId?: string;
+        namespace: string;
+        key: string;
+        value: unknown;
+        ttlSeconds?: number;
+        asUser?: string;
+    }): Promise<KvEntry>;
+    /** Idempotent - deleting an absent key succeeds. */
+    delete(input: {
+        workspaceId?: string;
+        namespace: string;
+        key: string;
+        asUser?: string;
+    }): Promise<void>;
+    private path;
+}

package/dist/types/server/resources/platform.d.ts

@@ -0,0 +1,32 @@
+import { type TransportOptions } from "../http.js";
+import type { CompanyProfile } from "../../types.js";
+/**
+ * Facts about the platform itself, rather than about a workspace or a user.
+ *
+ * One method today, and the resource exists anyway rather than hanging
+ * `getCompanyProfile` off `identity` or `workspaces`: neither of those is
+ * what it is about. This answers "who operates the thing my application runs
+ * on", which is a different subject from every other resource here, and a
+ * misfiled method is harder to find than an obvious one-method namespace.
+ */
+export declare class PlatformResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /**
+     * The operating entity's legal identity and its DPDP grievance channel.
+     *
+     * Takes no `workspaceId` and takes no `asUser` - the answer is the same for
+     * every tenant and every caller, because it is a fact about the platform.
+     *
+     * Returns the inner `companyProfile` rather than the envelope, matching
+     * `apps.list()` and `billing.listPlans()`: the wrapper is a wire detail, and
+     * every caller would destructure it on the next line.
+     *
+     * **Do not copy the result into your own configuration.** Cache it if you
+     * render it on a hot path - Connect already sends
+     * `s-maxage=3600, stale-while-revalidate=86400` - but the reason this is an
+     * endpoint at all is that a grievance officer copied into `.env` goes stale
+     * without anyone finding out.
+     */
+    getCompanyProfile(): Promise<CompanyProfile>;
+}

package/dist/types/server/resources/workspaces.d.ts

@@ -0,0 +1,55 @@
+import { type TransportOptions } from "../http.js";
+import type { ConnectWorkspaceMember, UserWorkspace, WorkspaceSwitchResult } from "../../types.js";
+/**
+ * Which workspaces the signed-in user belongs to, moving between them, and who
+ * else is on the team.
+ *
+ * **Every call here needs `asUser`** - the signed-in user's opaque
+ * `sessionToken`. There is no application-wide form of any of these: they take
+ * no `userId` and no `workspaceId`, and resolve both from the token. That is
+ * what makes the whole module safe to reach from a browser through
+ * `createConnectHandler`, and it is why a partner cannot enumerate another
+ * tenant's team with their own API key.
+ */
+export declare class WorkspacesResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /**
+     * The workspaces this user could switch to.
+     *
+     * Rows carry `inAudience` and `subscribed` so a switcher can show a
+     * workspace it cannot select, with the reason. Hiding it instead reads as
+     * data loss to the person who owns it.
+     */
+    list(options: {
+        asUser: string;
+    }): Promise<UserWorkspace[]>;
+    /**
+     * Moves this session to another workspace, returning a **new session
+     * token**. The one you passed is revoked.
+     *
+     * Persist the result before navigating - dropping it signs the user out,
+     * because the old token no longer works.
+     *
+     * Throws with status 404 when the workspace does not exist *or* the user is
+     * not a member (deliberately indistinguishable), and 403 when it is outside
+     * your audience, requires an MFA factor they have not enrolled, or is the
+     * workspace they are already on.
+     */
+    switch(input: {
+        workspaceId: string;
+    }, options: {
+        asUser: string;
+    }): Promise<WorkspaceSwitchResult>;
+    /**
+     * The team of the workspace this session is on.
+     *
+     * Members carry permissions already resolved for *your* application, not raw
+     * Connect roles - so you never reimplement Connect's role resolution, and
+     * you are told nothing about the customer's Connect account beyond what your
+     * application needs.
+     */
+    members(options: {
+        asUser: string;
+    }): Promise<ConnectWorkspaceMember[]>;
+}

package/dist/types/store-schema.d.ts

@@ -0,0 +1,52 @@
+import type { StoreQueryFilter, StoreOrderBy } from "./types.js";
+import { type StoreIndexField } from "./store.js";
+/**
+ * One collection as an application declares it, and the helpers that read a
+ * declaration back.
+ *
+ * The declaration is the same shape Connect stores on `Application.storeSchema`
+ * and the same one `scripts/seed-*-application.ts` writes there, so an app that
+ * builds its schema from its own query matrix can hand the result straight to
+ * anything here without a second type of its own. Connect remains the
+ * authority - this is a local copy of what was declared, useful for deriving
+ * things *from* the declaration, never for deciding access.
+ *
+ * Isomorphic and dependency-free, like the rest of the root entry.
+ */
+export interface StoreCollectionDeclaration {
+    name: string;
+    kind: "data" | "kv";
+    scope: "workspace" | "application";
+    /** Prose. Connect shows it in the Console; `deriveStoreTools` gives it to a model. */
+    description: string;
+    /** The per-user permission Connect checks when a call carries `asUser`. `null` means any member. */
+    readPermission: string | null;
+    writePermission: string | null;
+    /** Whether `data.scan` may read this collection across every workspace. */
+    crossWorkspace: boolean;
+    /** Create-only. Connect refuses a replace, a merge or a delete for every caller. */
+    appendOnly: boolean;
+    /** Nothing may be filtered, ordered or aggregated on a field not listed. */
+    queryableFields: string[];
+    indexes: {
+        fields: StoreIndexField[];
+    }[];
+}
+/** Whether one of `declared` can serve a query needing exactly `required`. */
+export declare function storeIndexCovers(declared: readonly {
+    fields: StoreIndexField[];
+}[], required: readonly StoreIndexField[]): boolean;
+/**
+ * Why a collection cannot serve a query, in words a caller can act on - or
+ * `null` when it can.
+ *
+ * Runs the same two rules Connect runs, in the same order: every field must be
+ * declared queryable, and the shape must be inside an automatic single-field
+ * index or covered by a declared composite one. Checking here rather than
+ * letting the call fail is not about saving a round trip - it is so the refusal
+ * can name the index to declare while the caller still has the query in hand.
+ */
+export declare function describeQueryRejection(collection: StoreCollectionDeclaration, query: {
+    filters?: readonly StoreQueryFilter[];
+    orderBy?: StoreOrderBy | null;
+}): string | null;