@rebasepro/types 0.16.0 → 0.16.1-canary.g0d7af95

package/src/types/collections.ts

@@ -3,11 +3,13 @@ import type { CollectionCallbacks } from "./entity_callbacks";
 import type { EnumValues, Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties";
 
 import type { User } from "../users";
+import type { EmailSendResult } from "../controllers/email";
 import type { Relation } from "./relations";
 import type { SecurityRule } from "./security_rules";
 import { getDataSourceCapabilities } from "./data_source";
 import type { WhereFilterOp, FilterValues, FilterPreset } from "./filter-operators";
 import type { SearchConfig } from "./search";
+import type { CollectionIndex } from "./indexes";
 
 /**
  * Base interface containing all driver-agnostic collection properties.
@@ -322,6 +324,24 @@ 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>>[];
 }
 
 /**
@@ -702,8 +722,14 @@ 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. */
-    sendEmail?: (options: { to: string; subject: string; html: string; text?: string }) => Promise<void>;
+    /**
+     * 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<EmailSendResult>;
     /** Whether the email service is configured and available. */
     emailConfigured: boolean;
     /** The app name from email config (for templates). */

package/src/types/component_ref.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/src/types/cron.ts

@@ -1,5 +1,4 @@
 import type { RebaseServerClient } from "../controllers/client";
-import type { RebaseSdkData } from "../controllers/data";
 
 /**
  * Cron Job type definitions for Rebase.
@@ -126,29 +125,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;
-    };
 }
 
 // =============================================================================

package/src/types/index.ts

@@ -6,6 +6,7 @@ export * from "./properties";
 export * from "./admin_block";
 export * from "./collections";
 export * from "./search";
+export * from "./indexes";
 export * from "./relations";
 export * from "./policy";
 export * from "./rls-functions";
@@ -14,8 +15,11 @@ export * from "./security_rules";
 export * from "./entity_callbacks";
 export * from "./websockets";
 export * from "./backend";
+export * from "./schema_editing";
 export * from "./channel_bus";
 export * from "./data_source";
+export * from "./resources";
+export * from "./resource_kinds";
 export * from "./storage_source";
 export * from "./cron";
 export * from "./backup";

package/src/types/indexes.ts

@@ -0,0 +1,180 @@
+/**
+ * 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>;

package/src/types/project_manifest.ts

@@ -26,6 +26,7 @@
  */
 
 import type { StorageSourceDefinition } from "./storage_source";
+import type { ResourceGraph } from "./resources";
 
 /**
  * Which kind of thing an app is.
@@ -61,7 +62,7 @@ export interface RebaseBackendAppConfig {
      *
      * Independent of *where* it runs. Both run on Rebase Cloud and both
      * self-host — the destination lives in `.rebase/cloud.json`, not here. See
-     * `docker/docker-compose.selfhost.yml`, which boots a managed bundle on a
+     * `infra/docker/docker-compose.selfhost.yml`, which boots a managed bundle on a
      * developer's own Docker host.
      *
      * This is authored rather than inferred on purpose. It is the single most
@@ -132,6 +133,38 @@ export interface RebaseStaticAppConfig {
 
 export type RebaseAppConfig = RebaseBackendAppConfig | RebaseStaticAppConfig;
 
+/**
+ * Path prefixes the backend owns, which no static app may claim.
+ *
+ * One process — and, on the platform, one hostname — serves both the API and
+ * however many static apps a project has. Mounting is longest-path-first, so an
+ * app declaring `/api` would win against the API itself and every request to it
+ * would be answered with that app's `index.html`: a 200 carrying HTML where the
+ * caller expected JSON, from a project that looks deployed and healthy.
+ *
+ * Declared here rather than in either enforcer because both must agree. The CLI
+ * checks it so a developer finds out while editing `rebase.json`; the control
+ * plane checks it again at deploy intake, because the front door's correctness
+ * cannot rest on a check that ran in somebody else's CLI — and a repository can
+ * be deployed by a CLI older than this rule.
+ */
+export const RESERVED_BACKEND_PREFIXES = ["/api", "/health", "/healthz", "/livez", "/readyz", "/metrics"] as const;
+
+/**
+ * Whether `path` collides with a prefix the backend owns.
+ *
+ * Compares at segment boundaries, so `/api` and `/api/v2` collide while
+ * `/apidocs` does not — the same rule the router matches with, because a check
+ * that is stricter than the router rejects paths that would have worked, and one
+ * that is looser admits paths that will not.
+ */
+export function reservedPrefixFor(path: string): string | undefined {
+    const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+    return RESERVED_BACKEND_PREFIXES.find(
+        reserved => normalized === reserved || normalized.startsWith(`${reserved}/`)
+    );
+}
+
 /**
  * One declared storage source, as authored in `rebase.json`.
  *
@@ -179,27 +212,20 @@ export interface RebaseProjectManifest {
      */
     apps: Record<string, RebaseAppConfig>;
     /**
-     * Storage sources this project uses, keyed by source key.
+     * Buckets are NOT declared here any more.
      *
-     * **Topology only — never credentials.** Which buckets exist is a property of
-     * the project and belongs in the repository; how to reach each one is a
-     * property of the deployment and lives in the environment, read per source
-     * from `<BASE>__<KEY>` (`S3_BUCKET__MEDIA` for a source keyed `media`). The
-     * default source takes no suffix, so a single-bucket project configured with
-     * plain `S3_BUCKET` keeps working having declared nothing at all.
+     * They were, and the runtime merged this block with the declarations in
+     * config code — a bucket named in both had one engine kept and the other
+     * silently discarded. Two homes for one concept, with a merge to decide
+     * between them, is the shape this whole model replaced.
      *
-     * Declared here rather than only in the config package because this file is
-     * the one artifact a host can read *before* running a build. That is what
-     * lets a console show "this project wants a `media` bucket, and it has none"
-     * on a project's first deploy, and it is why the managed and custom runtimes
-     * can present the same list — a custom build emits no bundle manifest, so a
-     * declaration that lived only in compiled config would leave every custom
-     * project invisible.
-     *
-     * Omitted entirely means one default source, which is the overwhelmingly
-     * common project and must not be required to say so.
+     * `bucket("media", { engine: "s3" })` in the project's config declares one
+     * now, and `rebase resources --write` generates `rebase.resources.json`,
+     * which is what a host reads before a build. A `storage` block left in this
+     * file is refused by the validator, by name, with the replacement in the
+     * message — not ignored, because a key that still parses and does nothing
+     * is the failure this removed.
      */
-    storage?: Record<string, RebaseStorageSourceConfig>;
     /**
      * Repository-wide opt-out from anonymous CLI usage sharing.
      *
@@ -279,6 +305,31 @@ export const BUNDLE_FORMAT_VERSION = 2;
  * any number of minors and patches while this stays put. It changes only when
  * the bundle/runtime contract breaks compatibility, and a project's
  * `manifest.runtime` range is matched against *this*.
+ *
+ * ## v2 — resources are declared, not configured
+ *
+ * `RebaseBackendConfig.dataSources` and `.storageSources` are gone. A project
+ * declares its databases and buckets with `database()` / `bucket()` in its
+ * config, and the runtime reads those declarations.
+ *
+ * This had to be a major, and the reason is the managed tier: it moves projects
+ * onto new images WITHOUT rebuilding them. A bundle built against v1 exports
+ * those keys, and a v2 runtime refuses them at boot — so without this bump, one
+ * image rollout would crash-loop every tenant that had ever declared a second
+ * database or bucket, in a wave, with the cause in a container log nobody is
+ * watching.
+ *
+ * With the bump, a v1 bundle on a v2 runtime is refused by
+ * `assertBundleCompatibility` with the remedy in the message, and the platform
+ * keeps it on a v1 image until it is rebuilt. That is the whole purpose of this
+ * number.
+ *
+ * **Release order matters and is not optional.** The control plane is the side
+ * that rejects, so it ships FIRST: raise `SUPPORTED_RUNTIME_CONTRACT` in the
+ * saas repo (it rejects only `contract >` its own, so it then accepts both),
+ * deploy that, and only then release a runtime implementing v2. Shipping the
+ * runtime first turns every deploy into a rejected intake blaming the tenant's
+ * bundle.
  */
 export const RUNTIME_CONTRACT_VERSION = 1;
 
@@ -333,6 +384,36 @@ export interface NativeDependency {
  * `manifest.json` — generated, and the document the runtime and control plane
  * both validate against.
  */
+/**
+ * One custom function, as recorded in a built bundle.
+ *
+ * @see RebaseBundleManifest.functions
+ */
+export interface RebaseBundleFunction {
+    /**
+     * The filename without its extension — which is also the URL segment it
+     * mounts at (`/api/functions/<name>`), the API-key permission that grants
+     * it, and the name `REBASE_FUNCTIONS_ONLY` selects by. One identity, used
+     * everywhere.
+     */
+    name: string;
+    /** Path inside the bundle, so a host can point at the file. */
+    file: string;
+    /**
+     * `false` when the function's own source imports a Node built-in or a
+     * package that needs one.
+     *
+     * Descriptive, never a gate: nothing refuses to build or deploy on this. It
+     * says where this function *could* run, not where it should.
+     */
+    portable: boolean;
+    /**
+     * Why it is not portable — one short phrase per reason, deduplicated.
+     * Absent when it is.
+     */
+    requires?: string[];
+}
+
 export interface RebaseBundleManifest {
     /** @see BUNDLE_FORMAT_VERSION */
     bundleFormat: number;
@@ -373,6 +454,28 @@ export interface RebaseBundleManifest {
     entry: RebaseBundleEntrypoints;
     /** Collection slugs contained in the bundle, for quick inspection. */
     collections?: string[];
+    /**
+     * Every custom function in the bundle, named and classified.
+     *
+     * Two things are recorded per function, and both are answers a host would
+     * otherwise have to get by importing user code:
+     *
+     * - **What it is called.** That name is the function's identity everywhere —
+     *   the URL segment it mounts at, the `functions/<name>` API-key
+     *   permission, the value `REBASE_FUNCTIONS_ONLY` selects by. A host that
+     *   wants to give one slow function its own replica count currently has to
+     *   boot the bundle to discover what is in it.
+     * - **Whether it needs Node.** Purely descriptive: a function that opens a
+     *   file or runs raw SQL is a fine function, and every deployment today is
+     *   a Node process. It is recorded because the question "which of these
+     *   could run somewhere else" has to be answerable from the artifact, and
+     *   because answering it per-file after the fact — across a codebase
+     *   already written — is the expensive version of the same question.
+     *
+     * Absent on a bundle built before this field existed, which is why every
+     * consumer must treat it as optional rather than as an empty list.
+     */
+    functions?: RebaseBundleFunction[];
     hooks: {
         /**
          * Whether the dependency closure contains native code.
@@ -401,17 +504,27 @@ export interface RebaseBundleManifest {
         /** Whether the config package exports a `storageAuthorize` hook. */
         authorize: boolean;
         /**
-         * Every storage source this bundle expects, resolved at build time from
-         * `rebase.json`'s `storage` block merged with any `storageSources` the
-         * config package exports.
+         * Buckets, on bundles built before {@link RebaseBundleManifest.resources}.
          *
-         * Recorded so the runtime does not have to import user code to learn its
-         * own topology, and so a host can tell — from the artifact alone, before
-         * starting anything — which buckets need configuring. Absent on bundles
-         * built before this field existed, which means one default source.
+         * No longer written. A host reads `resources`, which carries every kind
+         * in one list; this stays declared so a control plane can keep reading
+         * the bundles a project shipped before it was rebuilt.
          */
         sources?: StorageSourceDefinition[];
     };
+    /**
+     * Everything the project declares it needs — databases, buckets, topics,
+     * and whatever kind is registered next.
+     *
+     * Recorded so a host can tell, from the artifact alone and before starting
+     * anything, what a deploy will need provisioned. That question used to be
+     * answerable for buckets and for nothing else, because buckets were the
+     * only kind written into an artifact — which is how a project's databases
+     * became invisible to the platform that runs them.
+     *
+     * Absent on bundles built before this field existed.
+     */
+    resources?: ResourceGraph;
     deps: {
         /** Runtime dependencies of user code, as declared. */
         declared: Record<string, string>;

package/src/types/properties.ts

@@ -400,6 +400,48 @@ export interface BooleanProperty extends BaseProperty {
     validation?: PropertyValidationSchema;
 }
 
+/**
+ * Which pgvector distance a query measures with, and therefore which operator
+ * class an index has to be built for. The names match the `distance` option on
+ * `vectorSearch`, because an index built for one operator is not used by a
+ * query that asks for another.
+ *
+ * @group Entity properties
+ */
+export type VectorDistance = "cosine" | "l2" | "inner_product";
+
+/**
+ * How the ANN index over a vector column is built.
+ *
+ * Without an index, `vectorSearch` is an exact scan: correct at any size,
+ * and linear in the number of rows. With one, it is approximate and fast.
+ * That trade is why this is configurable rather than implied.
+ *
+ * @group Entity properties
+ */
+export interface VectorIndexConfig {
+    /**
+     * `hnsw` (the default) builds a navigable-graph index: slower to build,
+     * better recall, and it needs no training data, so it works on an empty
+     * table. `ivfflat` is cheaper to build but partitions by centroid, so an
+     * index built on an empty or tiny table has useless partitions — build it
+     * after the data is loaded, and set {@link lists}.
+     */
+    method?: "hnsw" | "ivfflat";
+    /**
+     * Which distance operators to index, defaulting to `cosine` — the default
+     * `vectorSearch` measures with. Name several to index several; each one is
+     * a separate index with its own build cost and its own storage.
+     */
+    distance?: VectorDistance | VectorDistance[];
+    /** HNSW: connections per node. Postgres defaults to 16. */
+    m?: number;
+    /** HNSW: candidate-list size while building. Postgres defaults to 64. */
+    efConstruction?: number;
+    /** IVFFlat: number of partitions. Postgres defaults to 100. */
+    lists?: number;
+}
+
 export interface VectorProperty extends BaseProperty {
     type: "vector";
     /**
@@ -407,6 +449,18 @@ export interface VectorProperty extends BaseProperty {
      */
     defaultValue?: Vector;
     dimensions: number;
+    /**
+     * ANN index configuration for this column.
+     *
+     * Omitted, a single HNSW index for cosine distance is created — which is
+     * what the default `vectorSearch` uses. `false` creates none, leaving
+     * `vectorSearch` an exact scan.
+     *
+     * Indexes are only created when {@link dimensions} is at most 2000:
+     * pgvector cannot index a wider `vector` column, so a 3072-dimension
+     * embedding is left unindexed rather than failing the boot.
+     */
+    index?: VectorIndexConfig | false;
     validation?: PropertyValidationSchema;
 }