@rebasepro/types 0.8.0 → 0.9.0

package/dist/rebase_context.d.ts

@@ -4,7 +4,7 @@ import type { StorageSource } from "./controllers/storage";
 import type { UserConfigurationPersistence } from "./controllers/local_config_persistence";
 import type { DatabaseAdmin } from "./types/backend";
 import type { RebaseClient } from "./controllers/client";
-import type { RebaseData } from "./controllers/data";
+import type { RebaseSdkData } from "./controllers/data";
 import type { User } from "./users";
 /**
  * Context that is provided to entity callbacks (hooks).
@@ -31,8 +31,12 @@ export type RebaseCallContext<USER extends User = User> = {
     /**
      * Unified data access — `context.data.products.create(...)`.
      * Access any collection as a dynamic property.
+     *
+     * Returns flat rows (`{ id, ...columns }`), identical to the frontend SDK
+     * client — so `context.data` in a backend callback and `client.data` in the
+     * frontend behave the same way (`row.title`, never `row.values.title`).
      */
-    data: RebaseData;
+    data: RebaseSdkData;
     /**
      * Used storage implementation
      */
@@ -64,9 +68,9 @@ export type RebaseContext<USER extends User = User, AuthControllerType extends A
      */
     sideDialogsController?: import("./controllers/side_dialogs_controller").SideDialogsController;
     /**
-     * Controller to open the side dialog displaying entity forms
+     * Controller to open the side panel displaying entity forms
      */
-    sideEntityController?: import("./controllers/side_entity_controller").SideEntityController;
+    sidePanelController?: import("./controllers/side_panel_controller").SidePanelController;
     /**
      * Controller resolving URLs in the CMS
      */

package/dist/types/auth_adapter.d.ts

@@ -212,6 +212,9 @@ export interface AuthResponsePayload {
         email: string;
         displayName: string | null;
         photoURL: string | null;
+        providerId?: string;
+        isAnonymous?: boolean;
+        emailVerified?: boolean;
         roles: string[];
         metadata: Record<string, unknown>;
     };
@@ -343,7 +346,7 @@ export interface AuthAdapter {
      *
      * @param values - Raw request body from the client.
      * @param collectionAuth - The parsed `AuthCollectionConfig` from the collection (if `auth` is an object).
-     * @returns Processed values ready for `driver.saveEntity()`, plus metadata for the post-save step.
+     * @returns Processed values ready for `driver.save()`, plus metadata for the post-save step.
      */
     prepareUserCreation?(values: Record<string, unknown>, collectionAuth?: unknown): Promise<UserCreationPrepareResult>;
     /**

package/dist/types/backend.d.ts

@@ -1,6 +1,6 @@
-import type { Entity } from "./entities";
-import type { EntityCollection, FilterValues, WhereFilterOp } from "./collections";
+import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections";
 import type { AuthAdapter } from "./auth_adapter";
+import type { HistoryConfig } from "../controllers/client";
 /**
  * Abstract database connection interface.
  * Represents a connection to any database system.
@@ -39,7 +39,7 @@ export interface FetchCollectionOptions<M extends Record<string, unknown> = Reco
     startAfter?: unknown;
     searchString?: string;
     databaseId?: string;
-    collection?: EntityCollection;
+    collection?: CollectionConfig;
 }
 /**
  * Options for searching entities
@@ -50,7 +50,7 @@ export interface SearchOptions<M extends Record<string, unknown> = Record<string
     order?: "desc" | "asc";
     limit?: number;
     databaseId?: string;
-    collection?: EntityCollection;
+    collection?: CollectionConfig;
 }
 /**
  * Options for counting entities
@@ -110,31 +110,31 @@ export type ConditionBuilderStatic<T = unknown> = {
  * - Relation resolution
  * - ID generation and conversion
  */
-export interface EntityRepository {
+export interface DataRepository {
     /**
      * Fetch a single entity by ID
      */
-    fetchEntity<M extends Record<string, unknown>>(collectionPath: string, entityId: string | number, databaseId?: string): Promise<Entity<M> | undefined>;
+    fetchOne<M extends Record<string, unknown>>(collectionPath: string, id: string | number, databaseId?: string): Promise<Record<string, unknown> | undefined>;
     /**
      * Fetch a collection of entities with optional filtering, ordering, and pagination
      */
-    fetchCollection<M extends Record<string, unknown>>(collectionPath: string, options?: FetchCollectionOptions<M>): Promise<Entity<M>[]>;
+    fetchCollection<M extends Record<string, unknown>>(collectionPath: string, options?: FetchCollectionOptions<M>): Promise<Record<string, unknown>[]>;
     /**
      * Search entities by text
      */
-    searchEntities<M extends Record<string, unknown>>(collectionPath: string, searchString: string, options?: SearchOptions<M>): Promise<Entity<M>[]>;
+    searchRows<M extends Record<string, unknown>>(collectionPath: string, searchString: string, options?: SearchOptions<M>): Promise<Record<string, unknown>[]>;
     /**
      * Count entities in a collection
      */
-    countEntities<M extends Record<string, unknown>>(collectionPath: string, options?: CountOptions<M>): Promise<number>;
+    count<M extends Record<string, unknown>>(collectionPath: string, options?: CountOptions<M>): Promise<number>;
     /**
-     * Save an entity (create or update)
+     * Save a entity (create or update)
      */
-    saveEntity<M extends Record<string, unknown>>(collectionPath: string, values: Partial<M>, entityId?: string | number, databaseId?: string): Promise<Entity<M>>;
+    save<M extends Record<string, unknown>>(collectionPath: string, values: Partial<M>, id?: string | number, databaseId?: string): Promise<Record<string, unknown>>;
     /**
-     * Delete an entity by ID
+     * Delete a entity by ID
      */
-    deleteEntity(collectionPath: string, entityId: string | number, databaseId?: string): Promise<void>;
+    delete(collectionPath: string, id: string | number, databaseId?: string): Promise<void>;
     /**
      * Check if a field value is unique in a collection
      */
@@ -157,10 +157,10 @@ export interface CollectionSubscriptionConfig {
 /**
  * Configuration for subscribing to a single entity
  */
-export interface EntitySubscriptionConfig {
+export interface SingleSubscriptionConfig {
     clientId: string;
     path: string;
-    entityId: string | number;
+    id: string | number;
 }
 /**
  * Abstract realtime provider interface.
@@ -170,19 +170,19 @@ export interface RealtimeProvider {
     /**
      * Subscribe to collection changes
      */
-    subscribeToCollection(subscriptionId: string, config: CollectionSubscriptionConfig, callback?: (entities: Entity[]) => void): void;
+    subscribeToCollection(subscriptionId: string, config: CollectionSubscriptionConfig, callback?: (rows: Record<string, unknown>[]) => void): void;
     /**
      * Subscribe to single entity changes
      */
-    subscribeToEntity(subscriptionId: string, config: EntitySubscriptionConfig, callback?: (entity: Entity | null) => void): void;
+    subscribeToOne(subscriptionId: string, config: SingleSubscriptionConfig, callback?: (row: Record<string, unknown> | null) => void): void;
     /**
      * Unsubscribe from a subscription
      */
     unsubscribe(subscriptionId: string): void;
     /**
-     * Notify all relevant subscribers of an entity update
+     * Notify all relevant subscribers of a entity update
      */
-    notifyEntityUpdate(path: string, entityId: string, entity: Entity | null, databaseId?: string): Promise<void>;
+    notifyUpdate(path: string, id: string, row: Record<string, unknown> | null, databaseId?: string): Promise<void>;
     /**
      * Called when the HTTP server is ready and listening.
      * Useful for providers that need the server address for callbacks.
@@ -210,15 +210,15 @@ export interface CollectionRegistryInterface {
     /**
      * Register a collection
      */
-    register(collection: EntityCollection): void;
+    register(collection: CollectionConfig): void;
     /**
      * Get a collection by its path
      */
-    getCollectionByPath(path: string): EntityCollection | undefined;
+    getCollectionByPath(path: string): CollectionConfig | undefined;
     /**
      * Get all registered collections
      */
-    getCollections(): EntityCollection[];
+    getCollections(): CollectionConfig[];
     /**
      * Get the currently registered global callbacks, if any.
      */
@@ -232,11 +232,11 @@ export interface DataTransformer {
     /**
      * Transform entity data for storage in the database
      */
-    serializeToDatabase<M extends Record<string, unknown>>(entity: M, collection: EntityCollection): Record<string, unknown>;
+    serializeToDatabase<M extends Record<string, unknown>>(entity: M, collection: CollectionConfig): Record<string, unknown>;
     /**
      * Transform database data back to entity format
      */
-    deserializeFromDatabase<M extends Record<string, unknown>>(data: Record<string, unknown>, collection: EntityCollection): Promise<M>;
+    deserializeFromDatabase<M extends Record<string, unknown>>(data: Record<string, unknown>, collection: CollectionConfig): Promise<M>;
 }
 /**
  * Administrative operations for SQL-based databases (PostgreSQL, MySQL, etc.).
@@ -427,7 +427,7 @@ export interface BackendInstance extends BackendLifecycle {
     /**
      * Entity repository for CRUD operations
      */
-    entityRepository: EntityRepository;
+    entityRepository: DataRepository;
     /**
      * Realtime provider for subscriptions
      */
@@ -518,7 +518,7 @@ export interface BackendBootstrapper {
      * Initialize history tables / services if this driver supports them.
      * Return undefined if history is not supported by this backend.
      */
-    initializeHistory?(config: unknown, driverResult: InitializedDriver): Promise<{
+    initializeHistory?(config: HistoryConfig, driverResult: InitializedDriver): Promise<{
         historyService: unknown;
     } | undefined>;
     /**

package/dist/types/builders.d.ts

@@ -1,9 +1,9 @@
 import type { AuthController } from "../controllers/auth";
 import type { RebaseData } from "../controllers/data";
 import type { User } from "../users";
-import type { EntityCollection } from "./collections";
+import type { CollectionConfig } from "./collections";
 import type { AppView } from "../controllers/navigation";
-export type EntityCollectionsBuilder<EC extends EntityCollection = EntityCollection> = (params: {
+export type CollectionConfigsBuilder<EC extends CollectionConfig = CollectionConfig> = (params: {
     user: User | null;
     authController: AuthController;
     data: RebaseData;

package/dist/types/collections.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import type { Entity, EntityStatus } from "./entities";
-import type { EntityCallbacks } from "./entity_callbacks";
+import type { CollectionCallbacks } from "./entity_callbacks";
 import type { Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties";
 import type { ExportConfig } from "./export_import";
 import type { User } from "../users";
@@ -11,16 +11,16 @@ import type { EntityAction } from "./entity_actions";
 import type { PolicyExpression } from "./policy";
 import type { ComponentRef } from "./component_ref";
 import type { CollectionComponentOverrideMap } from "./component_overrides";
-import type { FilterValues, FilterPreset } from "./filter-operators";
+import type { FilterValues, FilterPreset, OrderByTuple } from "./filter-operators";
 /**
  * Base interface containing all driver-agnostic collection properties.
- * Use {@link PostgresCollection} or {@link FirebaseCollection} for
- * driver-specific type safety, or {@link EntityCollection} when you
+ * Use {@link PostgresCollectionConfig} or {@link FirebaseCollectionConfig} for
+ * driver-specific type safety, or {@link CollectionConfig} when you
  * need to handle any collection regardless of backend.
  *
  * @group Models
  */
-export interface BaseEntityCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface BaseCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * You can set an alias that will be used internally instead of the collection name.
      * The `slug` value will be used to determine the URL of the collection.
@@ -48,12 +48,12 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      *
      * Custom drivers can set this directly to expose child collections to the UI.
      */
-    childCollections?: () => EntityCollection<Record<string, unknown>>[];
+    childCollections?: () => CollectionConfig<Record<string, unknown>>[];
     /**
      * The data source this collection belongs to — the routing key shared by
      * the frontend router and the backend driver registry. It points at a
      * {@link DataSourceDefinition} registered on `<Rebase dataSources>` (front)
-     * and `initRebase({ dataSources })` (back).
+     * and `initializeRebaseBackend({ dataSources })` (back).
      *
      * If not specified, the default data source `"(default)"` is used, which
      * for a standard Rebase app is the server-mediated Postgres backend.
@@ -70,8 +70,8 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * The database engine backing this collection (`"postgres"`, `"firestore"`,
      * `"mongodb"`, or a custom id).
      *
-     * On concrete collection types ({@link PostgresCollection},
-     * {@link FirebaseCollection}, {@link MongoDBCollection}) this is a literal
+     * On concrete collection types ({@link PostgresCollectionConfig},
+     * {@link FirebaseCollectionConfig}, {@link MongoDBCollectionConfig}) this is a literal
      * discriminant. On the base type it is optional and gets stamped
      * automatically during collection normalization from the registered
      * {@link DataSourceDefinition}.
@@ -90,7 +90,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     databaseId?: string;
     /**
-     * Set of properties that compose an entity
+     * Set of properties that compose a entity
      */
     properties: Properties;
     /**
@@ -125,12 +125,12 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     readonly titleProperty?: Extract<keyof M, string> | (string & {});
     /**
-     * When editing an entity, you can choose to open the entity in a side dialog
+     * When editing a entity, you can choose to open the entity in a side dialog
      * or in a full screen dialog. Defaults to `full_screen`.
      */
     openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
     /**
-     * Controls what happens when a user clicks on an entity in the collection view.
+     * Controls what happens when a user clicks on a entity in the collection view.
      * - `"edit"` (default): Opens the entity in the edit form.
      * - `"view"`: Opens a read-only detail view with an "Edit" button.
      */
@@ -177,19 +177,18 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * If you are specifying your collection as code, the order is the same as the
      * one you define in `properties`. Additional columns are added at the
      * end of the list, if the order is not specified.
+     *
      * You can use this prop to hide some properties from the table view.
      * Note that if you set this prop, other ways to hide fields, like
      * `hidden` in the property definition, will be ignored.
      * `propertiesOrder` has precedence over `hidden`.
-     *     - For properties use the property key.
-     *     - For additional fields use the field key.
-     *     - If you have subcollections, you get a column for each subcollection,
-     *       with the path (or alias) as the subcollection, prefixed with
-     *       `subcollection:`. e.g. `subcollection:orders`.
-     * You can use this prop to hide some properties from the table view.
-     * Note that if you set this prop, other ways to hide fields, like
-     * `hidden` in the property definition,will be ignored.
-     * `propertiesOrder` has precedence over `hidden`.
+     *
+     * Supported entry formats:
+     *     - For properties, use the property key.
+     *     - For additional fields, use the field key.
+     *     - Child collections (Firestore subcollections, or Postgres relations
+     *       with `many` cardinality) each get a column with id
+     *       `subcollection:<slug>`, e.g. `subcollection:orders`.
      */
     propertiesOrder?: (Extract<keyof M, string> | (string & {}) | string | `subcollection:${string}`)[];
     /**
@@ -202,11 +201,11 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     pagination?: boolean | number;
     selectionEnabled?: boolean;
     /**
-     * This interface defines all the callbacks that can be used when an entity
+     * This interface defines all the callbacks that can be used when a entity
      * is being created, updated or deleted.
      * Useful for adding your own logic or blocking the execution of the operation.
      */
-    readonly callbacks?: EntityCallbacks<M, USER>;
+    readonly callbacks?: CollectionCallbacks<M, USER>;
     /**
      * Pass your own selection controller if you want to control selected
      * entities externally.
@@ -251,7 +250,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * applied in the collection.
      * e.g. `sort: ["order", "asc"]`
      */
-    readonly sort?: [Extract<keyof M, string> | (string & {}), "asc" | "desc"];
+    readonly sort?: OrderByTuple<Extract<keyof M, string> | (string & {})>;
     /**
      * You can add additional fields to the collection view by implementing
      * an additional field delegate.
@@ -277,7 +276,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     hideFromNavigation?: boolean;
     /**
      * If you want to open custom views or subcollections by default when opening the edit
-     * view of an entity, you can specify the path to the view here.
+     * view of a entity, you can specify the path to the view here.
      * The path is relative to the current collection. For example if you have a collection
      * that has a custom view as well as a subcollection that refers to another entity, you can
      * either specify the path to the custom view or the path to the subcollection.
@@ -314,7 +313,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     metadata?: Record<string, unknown>;
     /**
-     * Width of the side dialog (in pixels) when opening an entity in this collection.
+     * Width of the side dialog (in pixels) when opening a entity in this collection.
      */
     sideDialogWidth?: number | string;
     /**
@@ -335,9 +334,9 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     /**
      * Should local changes be backed up in local storage, to prevent data loss on
      * accidental navigations.
-     * - `manual_apply`: When the user navigates back to an entity with local changes,
+     * - `manual_apply`: When the user navigates back to a entity with local changes,
      *   they will be prompted to restore the changes.
-     * - `auto_apply`: When the user navigates back to an entity with local changes,
+     * - `auto_apply`: When the user navigates back to a entity with local changes,
      *   the changes will be automatically applied.
      * - `false`: Local changes will not be backed up.
      * Defaults to `manual_apply`.
@@ -397,7 +396,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Security rules for this collection (Row Level Security).
      * When defined, the backend enforces access control policies.
      */
-    securityRules?: SecurityRule[];
+    securityRules?: readonly SecurityRule[];
     /**
      * Collection-scoped component overrides. These take precedence over
      * global overrides set on `<Rebase>`, but only within this collection's
@@ -409,7 +408,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      *
      * @example
      * ```tsx
-     * const productsCollection: PostgresCollection = {
+     * const productsCollection: PostgresCollectionConfig = {
      *     name: "Products",
      *     slug: "products",
      *     table: "products",
@@ -427,12 +426,12 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
  * A collection backed by PostgreSQL (or any SQL database).
  * Adds support for SQL-style relations (JOINs) and Row Level Security.
  *
- * Use this type instead of {@link EntityCollection} when you want
+ * Use this type instead of {@link CollectionConfig} when you want
  * compile-time safety that only SQL-relevant fields appear.
  *
  * @group Models
  */
-export interface PostgresCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseEntityCollection<M, USER> {
+export interface PostgresCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseCollectionConfig<M, USER> {
     properties: PostgresProperties;
     /**
      * The database engine for this collection. For Postgres collections this
@@ -455,7 +454,7 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
      */
     relations?: Relation[];
     /**
-     * Security rules for this collection (Supabase-style Row Level Security).
+     * Security rules for this collection (PostgreSQL Row Level Security).
      * When defined, the schema generator will enable RLS on the table and
      * create the corresponding PostgreSQL policies.
      *
@@ -469,24 +468,24 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
      * - `auth.roles()` — comma-separated app role IDs
      * - `auth.jwt()`   — full JWT claims as JSONB
      */
-    securityRules?: SecurityRule[];
+    securityRules?: readonly SecurityRule[];
 }
 /**
  * A collection backed by Firebase / Firestore.
  * Adds support for subcollections (nested document collections).
  *
- * Use this type instead of {@link EntityCollection} when you want
+ * Use this type instead of {@link CollectionConfig} when you want
  * compile-time safety that only Firestore-relevant fields appear.
  *
  * @group Models
  */
-export interface FirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseEntityCollection<M, USER> {
+export interface FirebaseCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseCollectionConfig<M, USER> {
     /**
      * The database engine for this collection. Must be set to `"firestore"`.
      */
     engine: "firestore";
     /**
-     * Set of properties that compose an entity.
+     * Set of properties that compose a entity.
      * Firestore collections support `reference` properties but not `relation`.
      */
     properties: FirebaseProperties;
@@ -497,7 +496,7 @@ export interface FirebaseCollection<M extends Record<string, unknown> = Record<s
      *
      * @example
      * ```typescript
-     * const fsCustomer: FirebaseCollection = {
+     * const fsCustomer: FirebaseCollectionConfig = {
      *     slug: "fs_customer",        // URL: /c/fs_customer
      *     path: "customer",           // Firestore path: customer
      *     name: "Customers (Firestore)",
@@ -510,25 +509,25 @@ export interface FirebaseCollection<M extends Record<string, unknown> = Record<s
     /**
      * You can add subcollections to your entity in the same way you define the root
      * collections. The collections added here will be displayed when opening
-     * the side dialog of an entity.
+     * the side dialog of a entity.
      */
-    subcollections?: () => EntityCollection<Record<string, unknown>>[];
+    subcollections?: () => CollectionConfig<Record<string, unknown>>[];
 }
 /**
  * A collection backed by MongoDB.
  *
- * Use this type instead of {@link EntityCollection} when you want
+ * Use this type instead of {@link CollectionConfig} when you want
  * compile-time safety that only MongoDB-relevant fields appear.
  *
  * @group Models
  */
-export interface MongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseEntityCollection<M, USER> {
+export interface MongoDBCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseCollectionConfig<M, USER> {
     /**
      * The database engine for this collection. Must be set to `"mongodb"`.
      */
     engine: "mongodb";
     /**
-     * Set of properties that compose an entity.
+     * Set of properties that compose a entity.
      * MongoDB collections support `reference` properties but not `relation`.
      */
     properties: MongoProperties;
@@ -539,7 +538,7 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
      *
      * @example
      * ```typescript
-     * const mongoCustomer: MongoDBCollection = {
+     * const mongoCustomer: MongoDBCollectionConfig = {
      *     slug: "mongo_customer",      // URL: /c/mongo_customer
      *     path: "customer",            // MongoDB collection: customer
      *     name: "Customers (MongoDB)",
@@ -552,35 +551,35 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
 }
 /**
  * A collection backed by any data source.
- * This is a discriminated union — use {@link PostgresCollection},
- * {@link FirebaseCollection}, or {@link MongoDBCollection} for
+ * This is a discriminated union — use {@link PostgresCollectionConfig},
+ * {@link FirebaseCollectionConfig}, or {@link MongoDBCollectionConfig} for
  * driver-specific type safety.
  *
  * @group Models
  */
-export type EntityCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = PostgresCollection<M, USER> | FirebaseCollection<M, USER> | MongoDBCollection<M, USER>;
+export type CollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = PostgresCollectionConfig<M, USER> | FirebaseCollectionConfig<M, USER> | MongoDBCollectionConfig<M, USER>;
 /**
  * Type guard for PostgreSQL collections.
  * Returns true if the collection uses the Postgres engine (or the default engine).
  * @group Models
  */
-export declare function isPostgresCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): collection is PostgresCollection<M, USER>;
+export declare function isPostgresCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: CollectionConfig<M, USER>): collection is PostgresCollectionConfig<M, USER>;
 /**
  * Type guard for Firebase / Firestore collections.
  * @group Models
  */
-export declare function isFirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): collection is FirebaseCollection<M, USER>;
+export declare function isFirebaseCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: CollectionConfig<M, USER>): collection is FirebaseCollectionConfig<M, USER>;
 /**
  * Type guard for MongoDB collections.
  * @group Models
  */
-export declare function isMongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): collection is MongoDBCollection<M, USER>;
+export declare function isMongoDBCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: CollectionConfig<M, USER>): collection is MongoDBCollectionConfig<M, USER>;
 /**
  * Returns the data path for a collection.
  * For Firestore or MongoDB collections with a `path`, returns that value;
  * otherwise falls back to `slug`.
  */
-export declare function getCollectionDataPath<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): string;
+export declare function getCollectionDataPath<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: CollectionConfig<M, USER>): string;
 /**
  * Reads a collection's driver-declared subcollections thunk (the `subcollections`
  * field) independent of engine identity, so engine-agnostic code doesn't have to
@@ -591,7 +590,7 @@ export declare function getCollectionDataPath<M extends Record<string, unknown>
  * whether the engine honours subcollections at all before reading them.
  * @group Models
  */
-export declare function getDeclaredSubcollections<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): (() => EntityCollection<Record<string, unknown>>[]) | undefined;
+export declare function getDeclaredSubcollections<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: CollectionConfig<M, USER>): (() => CollectionConfig<Record<string, unknown>>[]) | undefined;
 /**
  * Configuration for Kanban board view mode.
  * @group Collections
@@ -621,7 +620,7 @@ export type ViewMode = "list" | "table" | "cards" | "kanban";
  *
  * @group Models
  */
-export interface CollectionActionsProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User, EC extends EntityCollection<M> = EntityCollection<M>> {
+export interface CollectionActionsProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User, EC extends CollectionConfig<M> = CollectionConfig<M>> {
     /**
      * Full collection path of this entity. This is the full path, like
      * `users/1234/addresses`
@@ -677,7 +676,7 @@ export interface CollectionActionsProps<M extends Record<string, unknown> = Reco
 }
 /**
  * Use this controller to retrieve the selected entities or modify them in
- * an {@link EntityCollection}
+ * an {@link CollectionConfig}
  * @group Models
  */
 export interface SelectionController<M extends Record<string, unknown> = Record<string, unknown>> {
@@ -750,14 +749,14 @@ export interface AdditionalFieldDelegate<M extends Record<string, unknown> = Rec
         context: RebaseContext;
     }): string | number | Promise<string | number> | undefined;
 }
-export type InferCollectionType<S extends EntityCollection> = S extends EntityCollection<infer M> ? M : never;
+export type InferCollectionConfigType<S extends CollectionConfig> = S extends CollectionConfig<infer M> ? M : never;
 /**
- * Used in the {@link EntityCollection#defaultSelectedView} to define the default
+ * Used in the {@link CollectionConfig#defaultSelectedView} to define the default
  * @group Models
  */
 export type DefaultSelectedViewBuilder = (params: DefaultSelectedViewParams) => string | undefined;
 /**
- * Used in the {@link EntityCollection#defaultSelectedView} to define the default
+ * Used in the {@link CollectionConfig#defaultSelectedView} to define the default
  * @group Models
  */
 export type DefaultSelectedViewParams = {
@@ -810,7 +809,7 @@ export type SecurityOperation = "select" | "insert" | "update" | "delete" | "all
 /**
  * Flexible Row Level Security rule for a collection.
  *
- * Inspired by Supabase's approach to PostgreSQL RLS. Rules can range from
+ * Built on PostgreSQL Row Level Security. Rules can range from
  * simple convenience shortcuts to fully custom SQL expressions, giving you the
  * full power of PostgreSQL Row Level Security.
  *
@@ -823,7 +822,7 @@ export type SecurityOperation = "select" | "insert" | "update" | "delete" | "all
  *
  * **How rules combine:** PostgreSQL evaluates all matching policies for an
  * operation. Permissive rules are OR'd together (any one passing is enough).
- * Restrictive rules are AND'd (all must pass). This mirrors Supabase behavior.
+ * Restrictive rules are AND'd (all must pass). This is standard PostgreSQL RLS behavior.
  *
  * **Mutual exclusivity:** `ownerField`, `access`, structured `condition`, and
  * raw SQL (`using`/`withCheck`) cannot be combined. The type system enforces
@@ -882,7 +881,7 @@ export interface SecurityRuleBase {
      * // Equivalent to operation: "all"
      * { operations: ["all"], ownerField: "user_id" }
      */
-    operations?: SecurityOperation[];
+    operations?: readonly SecurityOperation[];
     /**
      * Whether this policy is `"permissive"` (default) or `"restrictive"`.
      *
@@ -891,7 +890,7 @@ export interface SecurityRuleBase {
      * - **restrictive**: Restrictive policies are AND'd with all permissive
      *   policies — they act as additional gates that *must* also pass.
      *
-     * This is the same model as PostgreSQL / Supabase.
+     * This is the standard PostgreSQL RLS model.
      *
      * @default "permissive"
      */
@@ -923,7 +922,7 @@ export interface SecurityRuleBase {
      * // Admins have unfiltered read access to all rows
      * { operation: "select", roles: ["admin"], using: "true" }
      */
-    roles?: string[];
+    roles?: readonly string[];
     /**
      * **Advanced.** Native PostgreSQL database roles the policy applies to.
      *
@@ -945,7 +944,7 @@ export interface SecurityRuleBase {
      * // Only apply this policy when connected as `app_role`
      * { operation: "select", access: "public", pgRoles: ["app_role"] }
      */
-    pgRoles?: string[];
+    pgRoles?: readonly string[];
 }
 /**
  * Security rule that grants access based on row ownership.