@rebasepro/types 0.7.0 → 0.8.0

package/dist/types/collections.d.ts

@@ -1,16 +1,17 @@
 import React from "react";
 import type { Entity, EntityStatus } from "./entities";
 import type { EntityCallbacks } from "./entity_callbacks";
-import type { Properties } from "./properties";
+import type { Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties";
 import type { ExportConfig } from "./export_import";
-import type { EntityOverrides } from "./entity_overrides";
 import type { User } from "../users";
 import type { RebaseContext } from "../rebase_context";
 import type { Relation } from "./relations";
 import type { EntityCustomView, FormViewConfig } from "./entity_views";
 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";
 /**
  * Base interface containing all driver-agnostic collection properties.
  * Use {@link PostgresCollection} or {@link FirebaseCollection} for
@@ -66,17 +67,18 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     dataSource?: string;
     /**
-     * The engine backing this collection (`"postgres"`, `"firestore"`,
-     * `"mongodb"`, or a custom id). Drives editor capabilities (relations vs
-     * subcollections, RLS, column types).
+     * The database engine backing this collection (`"postgres"`, `"firestore"`,
+     * `"mongodb"`, or a custom id).
      *
-     * @deprecated Prefer {@link dataSource} for routing. `driver` is retained
-     * as an engine hint and for backward compatibility: when `dataSource` is
-     * omitted it also acts as the data-source key.
+     * On concrete collection types ({@link PostgresCollection},
+     * {@link FirebaseCollection}, {@link MongoDBCollection}) this is a literal
+     * discriminant. On the base type it is optional and gets stamped
+     * automatically during collection normalization from the registered
+     * {@link DataSourceDefinition}.
      *
-     * If not specified, `"postgres"` is assumed.
+     * Prefer setting {@link dataSource} and letting the engine be resolved.
      */
-    driver?: string;
+    engine?: string;
     /**
      * Which database within the engine.
      * - For Firestore: The Firestore database ID (e.g., for multi-database projects)
@@ -261,8 +263,8 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     defaultSize?: CollectionSize;
     /**
      * Can the elements in this collection be edited inline in the collection
-     * view. If this flag is set to false but `permissions.edit` is `true`, entities
-     * can still be edited in the side panel
+     * view. Even when inline editing is disabled, entities can still be
+     * edited in the side panel (subject to `securityRules`).
      */
     inlineEditing?: boolean;
     /**
@@ -311,10 +313,6 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Used by domain apps to store custom per-collection config.
      */
     metadata?: Record<string, unknown>;
-    /**
-     * Overrides for the entity view, like the data source or the storage source.
-     */
-    overrides?: EntityOverrides;
     /**
      * Width of the side dialog (in pixels) when opening an entity in this collection.
      */
@@ -435,12 +433,12 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
  * @group Models
  */
 export interface PostgresCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseEntityCollection<M, USER> {
-    properties: Properties;
+    properties: PostgresProperties;
     /**
-     * The driver for this collection. For Postgres collections this
+     * The database engine for this collection. For Postgres collections this
      * can be omitted (Postgres is the default) or set to `"postgres"`.
      */
-    driver?: "postgres" | undefined;
+    engine?: "postgres" | undefined;
     /**
      * The PostgreSQL table name for this collection.
      */
@@ -484,9 +482,31 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
  */
 export interface FirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseEntityCollection<M, USER> {
     /**
-     * The driver for this collection. Must be set to `"firestore"`.
+     * The database engine for this collection. Must be set to `"firestore"`.
+     */
+    engine: "firestore";
+    /**
+     * Set of properties that compose an entity.
+     * Firestore collections support `reference` properties but not `relation`.
      */
-    driver: "firestore";
+    properties: FirebaseProperties;
+    /**
+     * The Firestore collection path to query. Defaults to `slug` if not set.
+     * Use this when the Firestore path differs from the slug
+     * (e.g., when a PostgreSQL collection already uses the same slug).
+     *
+     * @example
+     * ```typescript
+     * const fsCustomer: FirebaseCollection = {
+     *     slug: "fs_customer",        // URL: /c/fs_customer
+     *     path: "customer",           // Firestore path: customer
+     *     name: "Customers (Firestore)",
+     *     engine: "firestore",
+     *     properties: { ... }
+     * };
+     * ```
+     */
+    path?: string;
     /**
      * 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
@@ -504,9 +524,31 @@ export interface FirebaseCollection<M extends Record<string, unknown> = Record<s
  */
 export interface MongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> extends BaseEntityCollection<M, USER> {
     /**
-     * The driver for this collection. Must be set to `"mongodb"`.
+     * The database engine for this collection. Must be set to `"mongodb"`.
+     */
+    engine: "mongodb";
+    /**
+     * Set of properties that compose an entity.
+     * MongoDB collections support `reference` properties but not `relation`.
+     */
+    properties: MongoProperties;
+    /**
+     * The MongoDB collection name to use. Defaults to `slug` if not set.
+     * Use this when the MongoDB collection name differs from the slug
+     * (e.g., when a PostgreSQL collection already uses the same slug).
+     *
+     * @example
+     * ```typescript
+     * const mongoCustomer: MongoDBCollection = {
+     *     slug: "mongo_customer",      // URL: /c/mongo_customer
+     *     path: "customer",            // MongoDB collection: customer
+     *     name: "Customers (MongoDB)",
+     *     engine: "mongodb",
+     *     properties: { ... }
+     * };
+     * ```
      */
-    driver: "mongodb";
+    path?: string;
 }
 /**
  * A collection backed by any data source.
@@ -517,22 +559,9 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
  * @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>;
-/**
- * An EntityCollection that supports SQL-style relations (e.g. Postgres).
- * @deprecated Use `EntityCollection` directly — `table`, `relations`, and `securityRules` are now on `BaseEntityCollection`.
- */
-export type CollectionWithRelations<M extends Record<string, unknown> = Record<string, unknown>> = EntityCollection<M> & {
-    table?: string;
-    relations?: Relation[];
-    securityRules?: SecurityRule[];
-};
-/** An EntityCollection that supports subcollections (e.g. Firestore). */
-export type CollectionWithSubcollections<M extends Record<string, unknown> = Record<string, unknown>> = EntityCollection<M> & {
-    subcollections?: () => EntityCollection<Record<string, unknown>>[];
-};
 /**
  * Type guard for PostgreSQL collections.
- * Returns true if the collection uses the Postgres driver (or the default driver).
+ * 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>;
@@ -546,6 +575,23 @@ export declare function isFirebaseCollection<M extends Record<string, unknown> =
  * @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>;
+/**
+ * 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;
+/**
+ * Reads a collection's driver-declared subcollections thunk (the `subcollections`
+ * field) independent of engine identity, so engine-agnostic code doesn't have to
+ * type-guard against a specific driver. Returns `undefined` when the collection
+ * declares none.
+ *
+ * Pair with `getDataSourceCapabilities(engine).supportsSubcollections` to decide
+ * 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;
 /**
  * Configuration for Kanban board view mode.
  * @group Collections
@@ -641,42 +687,7 @@ export interface SelectionController<M extends Record<string, unknown> = Record<
     isEntitySelected(entity: Entity<M>): boolean;
     toggleEntitySelection(entity: Entity<M>, newSelectedState?: boolean): void;
 }
-/**
- * Filter conditions in a `Query.where()` clause are specified using the
- * strings `<`, `<=`, `==`, `>=`, `>`, `array-contains`, `in`, and `array-contains-any`.
- * @group Models
- */
-export type WhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-contains" | "in" | "not-in" | "array-contains-any";
-/**
- * Used to define filters applied in collections
- *
- * e.g. `{ age: [">=", 18] }`
- *
- * @group Models
- */
-export type FilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, unknown] | [WhereFilterOp, unknown][]>>;
-/**
- * A pre-defined filter preset for quick access in the collection toolbar.
- * Users can select a preset to instantly apply a set of filters and
- * optionally a sort order.
- *
- * @group Models
- */
-export interface FilterPreset<Key extends string = string> {
-    /**
-     * Display label shown in the preset menu.
-     * If omitted, a summary is auto-generated from the filter keys.
-     */
-    label?: string;
-    /**
-     * The filter values to apply when this preset is selected.
-     */
-    filterValues: FilterValues<Key>;
-    /**
-     * Optional sort override to apply alongside the filter values.
-     */
-    sort?: [Key, "asc" | "desc"];
-}
+export type { WhereFilterOp, FilterValues, WireFilterValues, FilterPreset } from "./filter-operators";
 /**
  * Used to indicate valid filter combinations (e.g. created in Firestore)
  * If the user selects a specific filter/sort combination, the CMS checks if it's
@@ -814,13 +825,21 @@ export type SecurityOperation = "select" | "insert" | "update" | "delete" | "all
  * operation. Permissive rules are OR'd together (any one passing is enough).
  * Restrictive rules are AND'd (all must pass). This mirrors Supabase behavior.
  *
- * **Mutual exclusivity:** `ownerField`, `access`, and raw SQL (`using`/`withCheck`)
- * cannot be combined. The type system enforces this — attempting to set
- * conflicting fields will produce a compile-time error.
+ * **Mutual exclusivity:** `ownerField`, `access`, structured `condition`, and
+ * raw SQL (`using`/`withCheck`) cannot be combined. The type system enforces
+ * this — attempting to set conflicting fields will produce a compile-time
+ * error.
+ *
+ * **Which form to reach for:** prefer the structured {@link StructuredSecurityRule}
+ * (`condition`/`check`) or the shortcuts (`ownerField`, `access`, `roles`). These
+ * are engine-agnostic and evaluated identically by the database and the admin UI,
+ * so the UI never shows an action the database will reject. Raw SQL
+ * ({@link RawSQLSecurityRule}) keeps full PostgreSQL power but is Postgres-only
+ * and server-authoritative (the UI cannot evaluate arbitrary SQL locally).
  *
  * @group Models
  */
-export type SecurityRule = OwnerSecurityRule | PublicSecurityRule | RawSQLSecurityRule | RolesOnlySecurityRule;
+export type SecurityRule = OwnerSecurityRule | PublicSecurityRule | StructuredSecurityRule | RawSQLSecurityRule | RolesOnlySecurityRule;
 /**
  * Shared fields for all SecurityRule variants.
  * @group Models
@@ -885,11 +904,16 @@ export interface SecurityRuleBase {
      * application roles managed by Rebase, stored in the `rebase.user_roles`
      * table, and injected into each transaction via `auth.roles()`.
      *
-     * Generates a condition like:
-     *   `auth.roles() ~ '<role1>|<role2>'`
+     * Generates a safe array-overlap condition — the user passes if they hold
+     * *any* of the listed roles:
+     *   `string_to_array(auth.roles(), ',') && ARRAY['<role1>', '<role2>']`
      *
-     * Can be combined with `ownerField`, `access`, or raw `using`/`withCheck`.
-     * When combined, the role check is AND'd with the other condition.
+     * (Note: this is a true set intersection, NOT a regex/substring match, so
+     * a role named `admin` never matches `nonadmin` or `superadmin`.)
+     *
+     * Can be combined with `ownerField`, `access`, `condition`, or raw
+     * `using`/`withCheck`. When combined, the role check is AND'd with the
+     * other condition.
      *
      * @example
      * // Only admins can delete
@@ -940,6 +964,8 @@ export interface OwnerSecurityRule extends SecurityRuleBase {
     access?: never;
     using?: never;
     withCheck?: never;
+    condition?: never;
+    check?: never;
 }
 /**
  * Security rule that grants unrestricted row access (no row filtering).
@@ -963,11 +989,57 @@ export interface PublicSecurityRule extends SecurityRuleBase {
     ownerField?: never;
     using?: never;
     withCheck?: never;
+    condition?: never;
+    check?: never;
+}
+/**
+ * Security rule expressed as a structured, engine-agnostic
+ * {@link PolicyExpression}. This is the **recommended** way to write a
+ * non-trivial condition: it compiles to PostgreSQL `USING`/`WITH CHECK` SQL
+ * *and* is evaluated identically by the admin UI, so the UI can never show an
+ * action the database will reject.
+ *
+ * Cannot be combined with `ownerField`, `access`, or raw `using`/`withCheck`.
+ *
+ * @example
+ * // Owner, or any user holding the `moderator` role
+ * {
+ *   operation: "update",
+ *   condition: policy.or(
+ *       policy.compare(policy.field("user_id"), "eq", policy.authUid()),
+ *       policy.rolesOverlap(["moderator"])
+ *   )
+ * }
+ *
+ * @group Models
+ */
+export interface StructuredSecurityRule extends SecurityRuleBase {
+    /**
+     * Structured condition for the `USING` clause — which *existing* rows are
+     * visible / can be modified / deleted (SELECT, UPDATE, DELETE).
+     */
+    condition: PolicyExpression;
+    /**
+     * Structured condition for the `WITH CHECK` clause — which *new/updated*
+     * row values are allowed (INSERT, UPDATE). Defaults to `condition` when
+     * omitted, mirroring PostgreSQL's own behavior.
+     */
+    check?: PolicyExpression;
+    ownerField?: never;
+    access?: never;
+    using?: never;
+    withCheck?: never;
 }
 /**
  * Security rule using raw SQL expressions for full PostgreSQL RLS power.
  *
- * Cannot be combined with `ownerField` or `access`.
+ * **Postgres-only and server-authoritative.** Arbitrary SQL cannot be
+ * evaluated by the admin UI, so a rule using this form is treated as *unknown*
+ * client-side (never silently allowed) and its effect on visible actions is
+ * reflected from the server. For conditions that should also drive the UI
+ * precisely, prefer the structured {@link StructuredSecurityRule}.
+ *
+ * Cannot be combined with `ownerField`, `access`, or structured `condition`.
  *
  * You can reference columns via `{column_name}` which will be resolved to
  * `table.column_name` in the generated Drizzle code.
@@ -1003,6 +1075,8 @@ export interface RawSQLSecurityRule extends SecurityRuleBase {
     withCheck?: string;
     ownerField?: never;
     access?: never;
+    condition?: never;
+    check?: never;
 }
 /**
  * Security rule that only filters by application roles, without any
@@ -1022,6 +1096,8 @@ export interface RolesOnlySecurityRule extends SecurityRuleBase {
     access?: never;
     using?: never;
     withCheck?: never;
+    condition?: never;
+    check?: never;
 }
 /**
  * Configuration for authentication collections.

package/dist/types/data_source.d.ts

@@ -128,11 +128,11 @@ export declare const MONGODB_CAPABILITIES: DataSourceCapabilities;
  */
 export declare const DEFAULT_CAPABILITIES: DataSourceCapabilities;
 /**
- * Look up capabilities for a given driver key.
- * If `driver` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
+ * Look up capabilities for a given engine key.
+ * If `engine` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
  * @group Models
  */
-export declare function getDataSourceCapabilities(driver?: string): DataSourceCapabilities;
+export declare function getDataSourceCapabilities(engine?: string): DataSourceCapabilities;
 /**
  * Register custom capabilities for a third-party driver.
  * @group Models

package/dist/types/entity_callbacks.d.ts

@@ -3,14 +3,24 @@ import type { Entity, EntityStatus, EntityValues } from "./entities";
 import type { User } from "../users";
 import type { RebaseCallContext } from "../rebase_context";
 /**
- * This interface defines all the callbacks that can be used when an entity
- * is being created, updated or deleted.
- * Useful for adding your own logic or blocking the execution of the operation.
+ * Lifecycle callbacks for entity CRUD operations.
+ *
+ * Register per-collection on the collection's `callbacks` field, or globally
+ * via `initBackend({ callbacks })`. Fires on **every** data path — REST API,
+ * WebSocket / realtime subscriptions, and server-side `rebase.data`.
+ *
+ * When both global and per-collection callbacks are registered, execution
+ * order is: **global → collection → property callbacks**.
+ *
  * @group Models
  */
 export type EntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = {
     /**
-     * Callback used after fetching data
+     * Callback used after fetching data.
+     *
+     * Fires on every read path. Use this for security-critical redaction
+     * (PII masking, row filtering) — no read path bypasses it.
+     *
      * @param props
      */
     afterRead?(props: EntityAfterReadProps<M, USER>): Promise<Entity<M>> | Entity<M>;
@@ -19,11 +29,13 @@ export type EntityCallbacks<M extends Record<string, unknown> = Record<string, u
      * saved. If you throw an error in this method the process stops, and an
      * error snackbar gets displayed.
      * This runs after schema validation.
+     *
      * @param props
      */
     beforeSave?(props: EntityBeforeSaveProps<M, USER>): Promise<Partial<EntityValues<M>>> | Partial<EntityValues<M>>;
     /**
-     * Callback used when save is successful
+     * Callback used when save is successful.
+     *
      * @param props
      */
     afterSave?(props: EntityAfterSaveProps<M, USER>): Promise<void> | void;
@@ -45,7 +57,7 @@ export type EntityCallbacks<M extends Record<string, unknown> = Record<string, u
      *
      * @param props
      */
-    afterDelete?(props: EntityAfterDeleteProps<M, USER>): void;
+    afterDelete?(props: EntityAfterDeleteProps<M, USER>): Promise<void> | void;
 };
 /**
  * Parameters passed to hooks when an entity is fetched

package/dist/types/filter-operators.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Canonical filter operators and REST wire-format mappings.
+ *
+ * `WhereFilterOp` is THE operator type used at every layer — from React
+ * components through the SDK, server, and down to the database driver.
+ *
+ * PostgREST short-codes (`eq`, `gt`, `cs`, …) exist **only** at the
+ * HTTP wire boundary, handled by `serializeFilter` / `deserializeFilter`
+ * in `@rebasepro/common`.
+ *
+ * ┌──────────────────┬───────────────┬──────────────────────────┐
+ * │ Canonical        │ REST short    │ Meaning                  │
+ * ├──────────────────┼───────────────┼──────────────────────────┤
+ * │ "=="             │ "eq"          │ Equal                    │
+ * │ "!="             │ "neq"         │ Not equal                │
+ * │ ">"              │ "gt"          │ Greater than             │
+ * │ ">="             │ "gte"         │ Greater than or equal    │
+ * │ "<"              │ "lt"          │ Less than                │
+ * │ "<="             │ "lte"         │ Less than or equal       │
+ * │ "in"             │ "in"          │ Value in list            │
+ * │ "not-in"         │ "nin"         │ Value not in list        │
+ * │ "array-contains" │ "cs"          │ Array contains element   │
+ * │ "array-contains-any" │ "csa"     │ Array contains any of    │
+ * └──────────────────┴───────────────┴──────────────────────────┘
+ *
+ * @module
+ */
+/**
+ * Canonical filter operators supported across all database backends.
+ * Each DB driver translates these to its native query format.
+ *
+ * @group Models
+ */
+export type WhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-contains" | "in" | "not-in" | "array-contains-any";
+/**
+ * Used to define filters applied in collections.
+ *
+ * A single condition is a tuple `[operator, value]`.
+ * Multiple conditions on the same field use an array of tuples.
+ *
+ * @example
+ * // Single condition per field
+ * { status: ["==", "active"], price: [">=", 9.99] }
+ *
+ * // Multiple conditions on one field
+ * { age: [[">=", 18], ["<", 65]] }
+ *
+ * // Array operators
+ * { role: ["in", ["admin", "editor"]] }
+ * { tags: ["array-contains", "featured"] }
+ *
+ * @group Models
+ */
+export type FilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, unknown] | [WhereFilterOp, unknown][]>>;
+/**
+ * Relaxed filter type that also accepts pre-serialized PostgREST strings.
+ * **Internal only** — used at the wire-format boundary
+ * (`serializeFilter` / `deserializeFilter` in `@rebasepro/common`).
+ *
+ * Application code, UI components, and SDK consumers should use
+ * {@link FilterValues} instead.
+ *
+ * @internal
+ */
+export type WireFilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, unknown] | [WhereFilterOp, unknown][] | string>>;
+/**
+ * A pre-defined filter preset for quick access in the collection toolbar.
+ * Users can select a preset to instantly apply a set of filters and
+ * optionally a sort order.
+ *
+ * @group Models
+ */
+export interface FilterPreset<Key extends string = string> {
+    /**
+     * Display label shown in the preset menu.
+     * If omitted, a summary is auto-generated from the filter keys.
+     */
+    label?: string;
+    /**
+     * The filter values to apply when this preset is selected.
+     */
+    filterValues: FilterValues<Key>;
+    /**
+     * Optional sort override to apply alongside the filter values.
+     */
+    sort?: [Key, "asc" | "desc"];
+}
+/**
+ * PostgREST short-code operators. Wire format only — these never appear
+ * in application code. Used by `serializeFilter`/`deserializeFilter`
+ * in `@rebasepro/common`.
+ */
+export type RestFilterOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "cs" | "csa";
+/** Maps canonical operators to their REST short-code equivalents. */
+export declare const CANONICAL_TO_REST: Readonly<Record<WhereFilterOp, RestFilterOp>>;
+/** Maps REST short-code operators to their canonical equivalents. */
+export declare const REST_TO_CANONICAL: Readonly<Record<RestFilterOp, WhereFilterOp>>;
+/**
+ * Resolve any operator string (canonical or REST short-code) to its
+ * canonical `WhereFilterOp` form. Returns `undefined` for unknown operators.
+ *
+ * @example
+ * toCanonicalOp("==")   // "=="
+ * toCanonicalOp("eq")   // "=="
+ * toCanonicalOp("cs")   // "array-contains"
+ * toCanonicalOp("xyz")  // undefined
+ */
+export declare function toCanonicalOp(op: string): WhereFilterOp | undefined;

package/dist/types/index.d.ts

@@ -1,13 +1,14 @@
 export * from "./entities";
+export * from "./filter-operators";
 export * from "./chips";
 export * from "./properties";
 export * from "./collections";
 export * from "./relations";
+export * from "./policy";
 export * from "./locales";
 export * from "./entity_link_builder";
 export * from "./user_management_delegate";
 export * from "./entity_callbacks";
-export * from "./entity_overrides";
 export * from "./export_import";
 export * from "./modify_collections";
 export * from "./formex";
@@ -21,8 +22,8 @@ export * from "./entity_actions";
 export * from "./property_config";
 export * from "./entity_views";
 export * from "./data_source";
+export * from "./storage_source";
 export * from "./cron";
-export * from "./backend_hooks";
 export * from "./component_ref";
 export * from "./auth_adapter";
 export * from "./database_adapter";