@rebasepro/types 0.16.0 → 0.16.1-canary.g0d7af95

package/dist/types/admin_block.d.ts

@@ -29,7 +29,7 @@
  *
  * @group Models
  */
-export declare const ADMIN_COLLECTION_KEYS: readonly ["Actions", "additionalFields", "alwaysApplyDefaultValues", "components", "customViews", "defaultEntityAction", "defaultFilter", "defaultSelectedView", "defaultSize", "defaultViewMode", "disableDefaultActions", "display", "enabledViews", "entityActions", "entityViews", "exportable", "filterPresets", "fixedFilter", "form", "formAutoSave", "formView", "group", "hideFromEntityViews", "hideFromNavigation", "hideIdFromCollection", "hideIdFromForm", "icon", "includeJsonView", "inlineEditing", "kanban", "listProperties", "localChangesBackup", "openEntityMode", "orderProperty", "pagination", "previewProperties", "propertiesOrder", "selectionController", "selectionEnabled", "sideDialogWidth", "sort", "titleProperty"];
+export declare const ADMIN_COLLECTION_KEYS: readonly ["Actions", "additionalFields", "alwaysApplyDefaultValues", "components", "customViews", "defaultEntityAction", "defaultFilter", "defaultSelectedView", "defaultSize", "defaultViewMode", "disableDefaultActions", "display", "enabledViews", "entityActions", "entityViews", "exportable", "filterPresets", "fixedFilter", "form", "formAutoSave", "formView", "group", "hideFromEntityViews", "hideFromNavigation", "hideIdFromCollection", "hideIdFromForm", "icon", "includeJsonView", "inlineEditing", "kanban", "listProperties", "localChangesBackup", "openEntityMode", "orderProperty", "pagination", "previewProperties", "propertiesOrder", "selectionController", "selectionEnabled", "sideDialogWidth", "sort"];
 /** A key of a collection's `admin` block. @group Models */
 export type AdminCollectionKey = typeof ADMIN_COLLECTION_KEYS[number];
 /**

package/dist/types/auth_adapter.d.ts

@@ -75,8 +75,16 @@ export interface AuthAdapterCapabilities {
     hasBuiltInAuthRoutes: boolean;
     /** Supports email/password login. */
     emailPasswordLogin: boolean;
-    /** Supports new user registration. */
-    registration: boolean;
+    /**
+     * Whether self-registration is open **right now**.
+     *
+     * A runtime answer, not a static feature list: the built-in adapter also
+     * reports `true` during the first-user bootstrap window (an empty user
+     * table) and `false` the moment `disableSelfRegistration` is set. Whatever
+     * this says, `POST /auth/register` does — both read the same predicate, so
+     * the UI can never be sent to a form that can only 403.
+     */
+    registrationEnabled: boolean;
     /**
      * Supports the end-user password reset flow (emailing a reset link).
      *
@@ -105,12 +113,15 @@ export interface AuthAdapterCapabilities {
     /** Supports passwordless magic link login. */
     magicLink: boolean;
     /**
-     * Whether `POST /auth/anonymous` will mint a credential-less session.
+     * Supports passwordless sign-in with a six-digit code sent by email.
      *
-     * Optional so an external adapter that predates the key keeps typechecking;
-     * absent means "this adapter does not offer anonymous sign-in".
+     * Optional so that an external adapter written before this existed still
+     * satisfies the interface; absent reads as "no", which is what an adapter
+     * that has never heard of the flow means.
      */
-    anonymousLogin?: boolean;
+    emailOtp?: boolean;
+    /** Whether `POST /auth/anonymous` will mint a credential-less session. */
+    anonymousLogin: boolean;
     /** List of enabled OAuth provider IDs (e.g. `["google", "github"]`). */
     enabledProviders: string[];
     /**
@@ -124,8 +135,6 @@ export interface AuthAdapterCapabilities {
      * Only applicable for built-in auth.
      */
     needsSetup?: boolean;
-    /** Whether new user registration is enabled (may differ from `registration` capability at runtime). */
-    registrationEnabled?: boolean;
 }
 /**
  * Options for paginated user listing.
@@ -284,7 +293,7 @@ export interface TransformAuthResponseContext {
     /** The authenticated user's ID. */
     uid: string;
     /** The auth method that triggered this response. */
-    method: "login" | "register" | "oauth" | "refresh" | "anonymous" | "magic-link" | "mfa";
+    method: "login" | "register" | "oauth" | "refresh" | "anonymous" | "magic-link" | "otp" | "mfa";
     /** The raw HTTP request (for reading headers, IP, etc.). */
     request: Request;
 }

package/dist/types/backend.d.ts

@@ -1,9 +1,10 @@
-import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections";
-import type { OrderByTuple } from "./filter-operators";
-import type { LogicalCondition } from "../controllers/data";
-import type { AuthAdapter } from "./auth_adapter";
-import type { HistoryConfig } from "../controllers/client";
-import type { ChannelBusSetting } from "./channel_bus";
+import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections.js";
+import type { OrderByTuple } from "./filter-operators.js";
+import type { LogicalCondition } from "../controllers/data.js";
+import type { AuthAdapter } from "./auth_adapter.js";
+import type { HistoryConfig } from "../controllers/client.js";
+import type { ChannelBusSetting } from "./channel_bus.js";
+import type { SchemaEditingAdmin } from "./schema_editing.js";
 /**
  * Abstract database connection interface.
  * Represents a connection to any database system.
@@ -433,7 +434,19 @@ export interface BranchAdmin {
  *
  * @group Admin
  */
-export type DatabaseAdmin = Partial<SQLAdmin> & Partial<DocumentAdmin> & Partial<SchemaAdmin> & Partial<BranchAdmin>;
+export type DatabaseAdmin = Partial<SQLAdmin> & Partial<DocumentAdmin> & Partial<SchemaAdmin> & Partial<BranchAdmin> & Partial<SchemaEditingAdmin>;
+/**
+ * Type guard: can this admin plan a live schema change?
+ *
+ * Planning is engine-specific — it renders DDL, a Drizzle schema and the
+ * declarative SQL artifacts — so the implementation lives in the driver
+ * package. The server detects the capability structurally, exactly as it does
+ * for SQL, rather than importing an engine it is supposed to know nothing
+ * about.
+ *
+ * @group Admin
+ */
+export declare function isSchemaEditingAdmin(admin: DatabaseAdmin | undefined): admin is SchemaEditingAdmin;
 /**
  * Type guard: does this admin support SQL operations?
  * @group Admin
@@ -697,7 +710,7 @@ export interface BackendBootstrapper {
     /**
      * Initialize WebSocket server for realtime operations.
      */
-    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: import("../controllers/data_driver").DataDriver, config?: unknown, authAdapter?: AuthAdapter): Promise<void> | void;
+    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: import("../controllers/data_driver.js").DataDriver, config?: unknown, authAdapter?: AuthAdapter): Promise<void> | void;
 }
 /**
  * Result of `BackendBootstrapper.initializeDriver()`.
@@ -705,7 +718,7 @@ export interface BackendBootstrapper {
  */
 export interface InitializedDriver {
     /** The DataDriver instance, ready for use. */
-    driver: import("../controllers/data_driver").DataDriver;
+    driver: import("../controllers/data_driver.js").DataDriver;
     /** The realtime service, if the driver created one during init. */
     realtimeProvider?: RealtimeProvider;
     /** A collection registry to register schema / tables into. */
@@ -716,7 +729,7 @@ export interface InitializedDriver {
      * Set by drivers that introspect in `baas` mode; the server serves these
      * instead of collections loaded from config files.
      */
-    collections?: import("./collections").CollectionConfig[];
+    collections?: import("./collections.js").CollectionConfig[];
     /** The underlying database connection (for lifecycle management). */
     connection?: DatabaseConnection;
     /**

package/dist/types/collection_contract.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionConfig } from "./collections";
+import type { CollectionConfig } from "./collections.js";
 /**
  * Serializing collections so they survive a network hop.
  *

package/dist/types/collections.d.ts

@@ -1,9 +1,11 @@
-import type { CollectionCallbacks } from "./entity_callbacks";
-import type { Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties";
-import type { User } from "../users";
-import type { Relation } from "./relations";
-import type { SecurityRule } from "./security_rules";
-import type { SearchConfig } from "./search";
+import type { CollectionCallbacks } from "./entity_callbacks.js";
+import type { Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties.js";
+import type { User } from "../users/index.js";
+import type { EmailSendResult } from "../controllers/email.js";
+import type { Relation } from "./relations.js";
+import type { SecurityRule } from "./security_rules.js";
+import type { SearchConfig } from "./search.js";
+import type { CollectionIndex } from "./indexes.js";
 /**
  * Base interface containing all driver-agnostic collection properties.
  * Use {@link PostgresCollectionConfig} or {@link FirebaseCollectionConfig} for
@@ -247,6 +249,23 @@ export interface PostgresCollectionConfig<M extends Record<string, unknown> = Re
      * @see SearchConfig
      */
     search?: SearchConfig;
+    /**
+     * Ordinary indexes on this collection's table.
+     *
+     * Collection-level, not per-property, because an index over two columns
+     * has no single property to hang on and a partial index has none at all —
+     * and because a second declaration site for the single-column case would
+     * put the same object in two places. An index's identity is a column list
+     * in an order; the single-column case is a degenerate one, not a special
+     * one.
+     *
+     * `VectorProperty.index` stays where it is: an ANN structure is a property
+     * of the column's type, not of a query.
+     *
+     * Postgres-only, like {@link SearchConfig}: refused on another engine
+     * rather than silently ignored.
+     */
+    indexes?: readonly CollectionIndex<Extract<keyof M, string>>[];
 }
 /**
  * A collection backed by Firebase / Firestore.
@@ -475,7 +494,7 @@ export interface EntityChildView<M extends Record<string, unknown> = Record<stri
     collection: CollectionConfig<M>;
     source: ChildViewSource;
 }
-export type { WhereFilterOp, FilterValues, WireFilterValues, FilterPreset } from "./filter-operators";
+export type { WhereFilterOp, FilterValues, WireFilterValues, FilterPreset } from "./filter-operators.js";
 export type InferCollectionConfigType<S extends CollectionConfig> = S extends CollectionConfig<infer M> ? M : never;
 /**
  * Configuration for authentication collections.
@@ -557,13 +576,19 @@ export interface AuthCollectionConfig {
 export interface AuthCollectionContext {
     /** Hash a password using the configured algorithm (scrypt by default). */
     hashPassword: (password: string) => Promise<string>;
-    /** Send an email. Only available when email service is configured. */
+    /**
+     * Send an email. Only available when email service is configured.
+     *
+     * Resolves with what the provider reported — the assigned Message-ID, most
+     * usefully — so a hook that sends a message can store the id and later
+     * thread a reply back to it. Callers that do not care may ignore it.
+     */
     sendEmail?: (options: {
         to: string;
         subject: string;
         html: string;
         text?: string;
-    }) => Promise<void>;
+    }) => Promise<EmailSendResult>;
     /** Whether the email service is configured and available. */
     emailConfigured: boolean;
     /** The app name from email config (for templates). */

package/dist/types/component_ref.d.ts

@@ -2,8 +2,9 @@
  * How a collection points at a UI component without the backend learning about React.
  *
  * This file is the hinge the BaaS/admin split turns on. `ComponentRef` is named
- * by `properties.ts` (`ui.Field`, `ui.Preview`, `ui.Filter`), and `properties.ts`
- * must stay in the React-free core because every backend subsystem — validation,
+ * by a property's `admin` block (`admin.Field`, `admin.Preview`, `admin.Filter`)
+ * and imported by `properties.ts`, which must stay in the React-free core
+ * because every backend subsystem — validation,
  * the drizzle schema generator, the OpenAPI generator, the SDK codegen — reads
  * property definitions. If `ComponentRef` needed `React.ComponentType`, the whole
  * property model would have to move to the admin layer with it.

package/dist/types/cron.d.ts

@@ -1,5 +1,4 @@
-import type { RebaseServerClient } from "../controllers/client";
-import type { RebaseSdkData } from "../controllers/data";
+import type { RebaseServerClient } from "../controllers/client.js";
 /**
  * Cron Job type definitions for Rebase.
  *
@@ -107,29 +106,6 @@ export interface CronJobContext {
      * });
      */
     rebase: RebaseServerClient;
-    /**
-     * The same object as {@link rebase}, under the name this context used
-     * before.
-     *
-     * @deprecated Use `rebase` instead. Two things made the old name a problem,
-     * and neither was cosmetic. It contradicted every other server surface,
-     * where the singleton is `rebase` — the previous docstring had to end with
-     * *"it is only named `client` here"*. And typing it as `RebaseClient`
-     * re-exposed `client.data`, the alias that {@link RebaseServerClient}
-     * deliberately `Omit`s so the RLS-bypassing plane has exactly one name and
-     * the privilege is visible at the call site. A reader who learned
-     * `client.data` here carried it to a collection callback, where
-     * `context.data` is the *user-scoped* plane — same spelling, opposite
-     * privilege.
-     *
-     * Still the full server client at runtime, and `data` still resolves, so
-     * existing cron files keep working and keep compiling. It will be removed
-     * in the next major.
-     */
-    client: RebaseServerClient & {
-        /** @deprecated Use `rebase.dataAsAdmin` — the name states the privilege. */
-        data: RebaseSdkData;
-    };
 }
 export type CronJobRunState = "idle" | "running" | "success" | "error" | "disabled";
 /**

package/dist/types/data_source.d.ts

@@ -1,4 +1,4 @@
-import { WhereFilterOp } from "./filter-operators";
+import { WhereFilterOp } from "./filter-operators.js";
 /**
  * Describes the capabilities and features supported by a data source (driver).
  *

package/dist/types/database_adapter.d.ts

@@ -19,10 +19,10 @@
  *
  * @group Backend
  */
-import type { DataDriver } from "../controllers/data_driver";
-import type { CollectionConfig } from "./collections";
-import type { CollectionRegistryInterface, DatabaseAdmin, InitializedDriver, RealtimeProvider, BootstrappedAuth } from "./backend";
-import type { HistoryConfig } from "../controllers/client";
+import type { DataDriver } from "../controllers/data_driver.js";
+import type { CollectionConfig } from "./collections.js";
+import type { CollectionRegistryInterface, DatabaseAdmin, InitializedDriver, RealtimeProvider, BootstrappedAuth } from "./backend.js";
+import type { HistoryConfig } from "../controllers/client.js";
 /**
  * A `DatabaseAdapter` provides data persistence for Rebase.
  *
@@ -74,7 +74,7 @@ export interface DatabaseAdapter {
      * here — turning an adapter-authenticated server's socket into one that
      * accepted every client as already authenticated.
      */
-    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: DataDriver, config?: unknown, adapter?: import("./auth_adapter").AuthAdapter): Promise<void> | void;
+    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: DataDriver, config?: unknown, adapter?: import("./auth_adapter.js").AuthAdapter): Promise<void> | void;
     /**
      * Bring the database's collection tables up to date, additively — the boot
      * companion to `db push`. See `BackendBootstrapper.ensureCollectionSchema`

package/dist/types/entities.d.ts

@@ -1,4 +1,4 @@
-import type { SearchMatch } from "./search";
+import type { SearchMatch } from "./search.js";
 /**
  * New or existing status
  * @group Models

package/dist/types/entity_callbacks.d.ts

@@ -1,7 +1,7 @@
-import type { CollectionConfig } from "./collections";
-import type { EntityStatus, EntityValues } from "./entities";
-import type { User } from "../users";
-import type { RebaseCallContext } from "../call_context";
+import type { CollectionConfig } from "./collections.js";
+import type { EntityStatus, EntityValues } from "./entities.js";
+import type { User } from "../users/index.js";
+import type { RebaseCallContext } from "../call_context.js";
 /**
  * Lifecycle callbacks for entity CRUD operations.
  *

package/dist/types/index.d.ts

@@ -1,29 +1,33 @@
-export * from "./entities";
-export * from "./filter-operators";
-export * from "./chips";
-export * from "./properties";
-export * from "./admin_block";
-export * from "./collections";
-export * from "./search";
-export * from "./relations";
-export * from "./policy";
-export * from "./rls-functions";
-export * from "./security_rules";
-export * from "./entity_callbacks";
-export * from "./websockets";
-export * from "./backend";
-export * from "./channel_bus";
-export * from "./data_source";
-export * from "./storage_source";
-export * from "./cron";
-export * from "./backup";
-export * from "./component_ref";
-export * from "./auth_adapter";
-export * from "./database_adapter";
-export * from "./api_keys";
-export * from "./history";
-export * from "./postgres_introspection";
-export * from "./project_manifest";
-export * from "./collection_contract";
-export * from "./schema_version";
-export * from "./storage_authorize";
+export * from "./entities.js";
+export * from "./filter-operators.js";
+export * from "./chips.js";
+export * from "./properties.js";
+export * from "./admin_block.js";
+export * from "./collections.js";
+export * from "./search.js";
+export * from "./indexes.js";
+export * from "./relations.js";
+export * from "./policy.js";
+export * from "./rls-functions.js";
+export * from "./security_rules.js";
+export * from "./entity_callbacks.js";
+export * from "./websockets.js";
+export * from "./backend.js";
+export * from "./schema_editing.js";
+export * from "./channel_bus.js";
+export * from "./data_source.js";
+export * from "./resources.js";
+export * from "./resource_kinds.js";
+export * from "./storage_source.js";
+export * from "./cron.js";
+export * from "./backup.js";
+export * from "./component_ref.js";
+export * from "./auth_adapter.js";
+export * from "./database_adapter.js";
+export * from "./api_keys.js";
+export * from "./history.js";
+export * from "./postgres_introspection.js";
+export * from "./project_manifest.js";
+export * from "./collection_contract.js";
+export * from "./schema_version.js";
+export * from "./storage_authorize.js";

package/dist/types/indexes.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Ordinary indexes, declared on a collection.
+ *
+ * Distinct from the two index-shaped things Rebase already builds. A `search`
+ * block builds a GIN index over a generated `tsvector`, and a `vector`
+ * property builds an ANN index over an embedding; both are structures the
+ * *feature* owns and neither is a query the developer wrote. This is the plain
+ * case — the btree behind a `where` clause — which had no declaration site at
+ * all, so the only way to have one was to write it by hand, where the next
+ * `rebase db push` planned it away.
+ *
+ * Every form here is core Postgres, deliberately. See {@link CollectionIndex}.
+ */
+/**
+ * A key column of an index whose access method has no ordering.
+ *
+ * `gin` and `brin` reject `ASC`/`DESC`/`NULLS` outright — Postgres answers
+ * `access method "gin" does not support ASC/DESC options` — so those methods
+ * take this narrower shape and the combination is unrepresentable rather than
+ * refused at build time.
+ */
+export interface UnorderedIndexKey<Keys extends string = string> {
+    /**
+     * A property key on this collection — never a column name.
+     *
+     * Which column that resolves to depends on the property, and the two
+     * differ in exactly the case an index is most often wanted for: a
+     * `belongsTo` relation compiles to its resolved `localKey`
+     * (`primaryCategory` → `primary_category_id`), not to the snake-cased
+     * property key. Anything else resolves through `columnName`, or the
+     * snake-case default when it declares none.
+     *
+     * Writing the column name here would work for most properties and quietly
+     * index nothing for a foreign key, which is the one people reach for.
+     */
+    prop: Keys | (string & {});
+}
+/**
+ * A key column of an index, when its order matters.
+ *
+ * `direction` and `nulls` earn their place only when a query's `ORDER BY`
+ * mixes directions. A lone `DESC` index is redundant with its `ASC` twin —
+ * Postgres scans a btree backwards just as fast — and declaring both is
+ * refused.
+ *
+ * Writing the Postgres default down explicitly is free: the derived name
+ * hashes the *effective* order, so adding `direction: "asc"` to a column that
+ * was already ascending is not a redefinition and rebuilds nothing.
+ */
+export interface IndexKey<Keys extends string = string> extends UnorderedIndexKey<Keys> {
+    direction?: "asc" | "desc";
+    /** Postgres's own default: `last` under `asc`, `first` under `desc`. */
+    nulls?: "first" | "last";
+}
+/**
+ * The rows a partial index covers.
+ *
+ * Structure rather than a SQL string, and this is the most load-bearing choice
+ * in the type. A string would be replayed verbatim by Atlas in a scratch
+ * database, would be the one place a caller reaches for an extension operator
+ * class or a subquery, could not be checked against the collection's
+ * properties, and could not be fingerprinted — its own text would have to go
+ * into the derived name, so reformatting it would rename a live index.
+ *
+ * Structure keeps every reference resolvable at build time, keeps literals
+ * going through the same quoting as the rest of the DDL, and keeps the name
+ * stable under any rendering change.
+ *
+ * There is no `or`. An OR predicate almost always means the index should not
+ * be partial at all; a caller who genuinely needs one declares two indexes.
+ */
+export type IndexPredicate<Keys extends string = string> = {
+    prop: Keys | (string & {});
+    op: "=";
+    value: string | number | boolean;
+} | {
+    prop: Keys | (string & {});
+    op: "!=" | "<" | "<=" | ">" | ">=";
+    value: string | number;
+} | {
+    prop: Keys | (string & {});
+    op: "is null" | "is not null";
+}
+/**
+ * A non-empty list, enforced in the type. An empty `IN` is a predicate
+ * matching nothing: it builds an index over zero rows and reports success,
+ * which is the silent-empty-condition shape this codebase has been bitten
+ * by before.
+ */
+ | {
+    prop: Keys | (string & {});
+    op: "in";
+    value: readonly [string | number, ...(string | number)[]];
+} | {
+    and: readonly [IndexPredicate<Keys>, ...IndexPredicate<Keys>[]];
+};
+interface BaseCollectionIndex<Keys extends string = string> {
+    /**
+     * The key columns, in order. This *is* the index's identity.
+     *
+     * Postgres can only use a leading subset, so `["ownerId", "createdAt"]`
+     * serves a query filtering on `ownerId`, and one filtering on both, and
+     * never one filtering on `createdAt` alone.
+     *
+     * Capped at five keys. Postgres allows thirty-two; past four the trailing
+     * columns are dead weight on every write, and the declaration is usually
+     * someone hoping a query gets faster by accretion. Payload columns that
+     * are not searched belong in `include`, which does not count against this.
+     */
+    on: readonly [Keys | IndexKey<Keys>, ...(Keys | IndexKey<Keys>)[]];
+    where?: IndexPredicate<Keys>;
+    /**
+     * Why this index exists, in one line. Required, and the only required
+     * field carrying no SQL.
+     *
+     * An index is the only thing a Rebase config can declare that costs money
+     * forever and whose benefit is invisible from the config. `rebase doctor`
+     * prints this beside "0 scans in 34 days, 412 MB", which is the one moment
+     * anyone is in a position to decide whether to delete it. Without it
+     * nobody can decide, so nobody does, and the table accretes indexes for
+     * the life of the product.
+     */
+    reason: string;
+}
+/**
+ * The default. Answers equality, range, `ORDER BY`, and uniqueness.
+ */
+export interface BtreeIndex<Keys extends string = string> extends BaseCollectionIndex<Keys> {
+    using?: "btree";
+    /**
+     * A composite uniqueness guarantee.
+     *
+     * Single-column uniqueness is `validation.unique` on the property, and
+     * declaring it here is refused rather than accepted as a synonym.
+     * `validation.unique` compiles to an inline `UNIQUE` whose backing index
+     * Postgres — not Rebase — names `<table>_<column>_key`. That name is in
+     * every deployed database, appears in no contract file, and no release can
+     * reach in and rename it.
+     */
+    unique?: boolean;
+    /**
+     * Payload columns carried in the leaf pages, for index-only scans. Not
+     * searchable and not ordered — they save a heap fetch at the cost of a
+     * fatter index. May not overlap `on`.
+     */
+    include?: readonly (Keys | (string & {}))[];
+}
+/**
+ * Containment over an `array` property or a JSONB `map`, using core operator
+ * classes only. Trigram and full-text search are `search:`, not this.
+ */
+export interface GinIndex<Keys extends string = string> extends BaseCollectionIndex<Keys> {
+    using: "gin";
+    on: readonly [Keys | UnorderedIndexKey<Keys>, ...(Keys | UnorderedIndexKey<Keys>)[]];
+}
+/**
+ * A naturally-ordered column on an append-only table — tiny, and useless the
+ * moment rows arrive out of order.
+ */
+export interface BrinIndex<Keys extends string = string> extends BaseCollectionIndex<Keys> {
+    using: "brin";
+    on: readonly [Keys | UnorderedIndexKey<Keys>, ...(Keys | UnorderedIndexKey<Keys>)[]];
+}
+/**
+ * An index on a collection's table.
+ *
+ * No `gist` and no `hash`: every interesting gist operator class ships in an
+ * extension, and hash indexes cannot be unique, composite, or ordered.
+ *
+ * The restriction to core Postgres is not conservatism, it is what keeps the
+ * whole model on the Atlas path. `rebase db push` materialises the desired
+ * state in a bare scratch database to plan against, `--exclude` does not
+ * suppress that replay, and `CREATE EXTENSION` cannot be put in the file — so
+ * an index needing `gin_trgm_ops` or `vector_cosine_ops` is refused at build
+ * time rather than emitted to fail later against a database the author has
+ * never heard of. Trigram search is `search:`; ANN is a `vector` property.
+ */
+export type CollectionIndex<Keys extends string = string> = BtreeIndex<Keys> | GinIndex<Keys> | BrinIndex<Keys>;
+export {};