@rebasepro/types 0.8.0 → 0.9.0

package/dist/types/component_overrides.d.ts

@@ -1,4 +1,6 @@
 import type React from "react";
+import type { Property } from "./properties";
+import type { WhereFilterOp } from "./filter-operators";
 /**
  * Components that can only be overridden at the **app level** via the
  * `components` prop on `<Rebase>`.
@@ -20,12 +22,68 @@ export type AppComponentName = "Shell.AppBar" | "Shell.Drawer" | "Shell.DrawerNa
  *
  * @group Component Overrides
  */
-export type CollectionComponentName = "Collection.View" | "Collection.Table" | "Collection.Card" | "Collection.EmptyState" | "Collection.Actions" | "Entity.Form" | "Entity.FormActions" | "Entity.DetailView" | "Entity.SidePanel" | "Entity.Preview" | "Entity.MissingReference";
+export type CollectionComponentName = "Collection.View" | "Collection.Table" | "Collection.Card" | "Collection.EmptyState" | "Collection.Actions" | "Collection.FilterField" | "Entity.Form" | "EditView.FormActions" | "DetailView" | "Entity.SidePanel" | "EntityPreview" | "Entity.MissingReference";
 /**
  * All overridable component names across all scopes.
  * @group Component Overrides
  */
 export type OverridableComponentName = AppComponentName | CollectionComponentName;
+/**
+ * Props received by a filter field component — whether it is a built-in
+ * per-type field, a property-level replacement (`property.ui.Filter`), or a
+ * `"Collection.FilterField"` override.
+ *
+ * The `operators` list is **already resolved**: it is the intersection of the
+ * engine's {@link DataSourceCapabilities.filterOperators}, the property-type
+ * defaults, and any `property.ui.filterOperators` narrowing. A custom field
+ * should only offer operators from this list — anything else may throw at
+ * query time on engines that cannot execute it.
+ *
+ * @example
+ * ```tsx
+ * function MyStatusFilter({ value, setValue, operators }: FilterFieldBindingProps) {
+ *     return (
+ *         <select
+ *             value={value?.[1] as string ?? ""}
+ *             onChange={e => setValue(e.target.value ? ["==", e.target.value] : undefined)}>
+ *             <option value="">Any</option>
+ *             <option value="active">Active</option>
+ *             <option value="archived">Archived</option>
+ *         </select>
+ *     );
+ * }
+ * ```
+ *
+ * @group Component Overrides
+ */
+export interface FilterFieldBindingProps {
+    /** Key of the property being filtered (the column id). */
+    propertyKey: string;
+    /**
+     * The resolved property. For array properties this is the **item**
+     * property (`property.of`), with `isArray` set to true.
+     */
+    property: Property;
+    /** True when the underlying property is an array of `property`. */
+    isArray: boolean;
+    /**
+     * Operators this field may offer, already narrowed by engine
+     * capabilities, property-type defaults, and `property.ui.filterOperators`.
+     */
+    operators: readonly WhereFilterOp[];
+    /** Current filter condition for this property, if any. */
+    value?: [WhereFilterOp, unknown];
+    /** Set (or clear, with `undefined`) the filter condition. */
+    setValue: (value?: [WhereFilterOp, unknown]) => void;
+    /** Display title for the field (usually the property name). */
+    title?: string;
+    /**
+     * Coordination flags used by fields that open their own dialogs
+     * (e.g. the reference picker hides the parent filters dialog).
+     */
+    hidden?: boolean;
+    setHidden?: (hidden: boolean) => void;
+}
 /**
  * A single component override entry.
  *
@@ -55,7 +113,7 @@ export type OverridableComponentName = AppComponentName | CollectionComponentNam
  *
  * @group Component Overrides
  */
-export interface ComponentOverride<P = any> {
+export interface ComponentOverride<P = Record<string, unknown>> {
     /**
      * The replacement component. Receives the same props as the built-in
      * component it replaces.
@@ -122,7 +180,7 @@ export type CollectionComponentOverrideMap = {
  *         "HomePage": { Component: MyDashboard },
  *
  *         // Collection defaults: apply to ALL collections
- *         "Entity.FormActions": {
+ *         "EditView.FormActions": {
  *             Component: MyFormActions,
  *             wrap: true
  *         },

package/dist/types/cron.d.ts

@@ -43,7 +43,16 @@ export interface CronJobContext {
     scheduledAt: Date;
     /** A simple logger scoped to this job run. */
     log: (...args: unknown[]) => void;
-    /** The RebaseClient instance to interact with the database. */
+    /**
+     * The server-side {@link RebaseClient}. This is the **same singleton**
+     * exposed as `rebase` (imported from `@rebasepro/server-core`) and as
+     * `context` in collection callbacks — it is only named `client` here.
+     *
+     * Its data plane (`client.data`) runs with **admin privileges and bypasses
+     * RLS** (`{ uid: "service", roles: ["admin"] }`). There is no per-request
+     * user in a cron, so treat every query as fully trusted and scope your own
+     * filters explicitly.
+     */
     client: RebaseClient;
 }
 export type CronJobRunState = "idle" | "running" | "success" | "error" | "disabled";

package/dist/types/data_source.d.ts

@@ -1,3 +1,4 @@
+import { WhereFilterOp } from "./filter-operators";
 /**
  * Describes the capabilities and features supported by a data source (driver).
  *
@@ -26,6 +27,16 @@ export interface DataSourceCapabilities {
     supportsColumnTypes: boolean;
     /** Does this source support real-time listeners? */
     supportsRealtime: boolean;
+    /**
+     * Canonical filter operators this engine can execute.
+     *
+     * The admin UI intersects this set with the property-type defaults and
+     * any per-property narrowing (`property.ui.filterOperators`) to decide
+     * which operators to offer in filter fields — so an engine that cannot
+     * run `ilike` (e.g. Firestore) never shows a "Contains" filter that
+     * would throw at query time.
+     */
+    filterOperators: readonly WhereFilterOp[];
     /** Does this source support SQL admin operations (SQL editor, EXPLAIN, etc.)? */
     supportsSQLAdmin: boolean;
     /** Does this source support document admin operations (aggregation, stats)? */
@@ -84,9 +95,11 @@ export interface DataSourceDefinition {
      */
     engine: string;
     /**
-     * How the frontend reaches this source. Defaults to `"server"`.
+     * How the frontend reaches this source. Optional — when omitted it is
+     * inferred: `"direct"` if the definition carries a client-side driver,
+     * `"server"` otherwise.
      */
-    transport: DataSourceTransport;
+    transport?: DataSourceTransport;
     /**
      * The physical database/schema/Firestore-database within the engine.
      * Threaded to drivers/adapters as the existing `databaseId` runtime

package/dist/types/database_adapter.d.ts

@@ -20,8 +20,9 @@
  * @group Backend
  */
 import type { DataDriver } from "../controllers/data_driver";
-import type { EntityCollection } from "./collections";
+import type { CollectionConfig } from "./collections";
 import type { CollectionRegistryInterface, DatabaseAdmin, InitializedDriver, RealtimeProvider, BootstrappedAuth } from "./backend";
+import type { HistoryConfig } from "../controllers/client";
 /**
  * A `DatabaseAdapter` provides data persistence for Rebase.
  *
@@ -59,7 +60,7 @@ export interface DatabaseAdapter {
      *
      * Return `undefined` if the database does not support history.
      */
-    initializeHistory?(config: unknown, driverResult: InitializedDriver): Promise<{
+    initializeHistory?(config: HistoryConfig, driverResult: InitializedDriver): Promise<{
         historyService: unknown;
     } | undefined>;
     /**
@@ -88,7 +89,7 @@ export interface DatabaseAdapter {
  */
 export interface DatabaseAdapterInitConfig {
     /** Registered collection definitions. */
-    collections: EntityCollection[];
+    collections: CollectionConfig[];
     /** The shared collection registry to register into. */
     collectionRegistry: CollectionRegistryInterface;
 }

package/dist/types/entities.d.ts

@@ -4,7 +4,7 @@
  */
 export type EntityStatus = "new" | "existing" | "copy";
 /**
- * Representation of an entity fetched from the driver
+ * Representation of a entity fetched from the driver
  * @group Models
  */
 export interface Entity<M extends Record<string, unknown> = Record<string, unknown>> {
@@ -39,7 +39,7 @@ export interface Entity<M extends Record<string, unknown> = Record<string, unkno
  */
 export type EntityValues<M extends Record<string, unknown>> = M;
 /**
- * Props for creating an EntityReference
+ * Props for creating a EntityReference
  */
 export interface EntityReferenceProps {
     /** ID of the entity */
@@ -52,7 +52,7 @@ export interface EntityReferenceProps {
     databaseId?: string;
 }
 /**
- * Class used to create a reference to an entity in a different path.
+ * Class used to create a reference to a entity in a different path.
  *
  * @example
  * // Simple reference (most common case - single driver, single db)
@@ -86,7 +86,7 @@ export declare class EntityReference {
      */
     readonly databaseId?: string;
     /**
-     * Create a reference to an entity.
+     * Create a reference to a entity.
      *
      * @example
      * // Simple reference (most common case)
@@ -105,7 +105,7 @@ export declare class EntityReference {
     isEntityReference(): boolean;
 }
 /**
- * Class used to create a reference to an entity in a different path
+ * Class used to create a reference to a entity in a different path
  */
 export declare class EntityRelation {
     readonly __type = "relation";
@@ -122,8 +122,8 @@ export declare class EntityRelation {
      * Pre-fetched data payload to eliminate N+1 queries.
      * When present, clients can use this directly instead of fetching.
      */
-    readonly data?: Entity;
-    constructor(id: string | number, path: string, data?: Entity);
+    readonly data?: Record<string, unknown>;
+    constructor(id: string | number, path: string, data?: Record<string, unknown>);
     get pathWithId(): string;
     isEntityReference(): boolean;
     isEntityRelation(): boolean;

package/dist/types/entity_actions.d.ts

@@ -1,12 +1,12 @@
 import React from "react";
 import type { Entity } from "./entities";
-import type { EntityCollection, SelectionController } from "./collections";
+import type { CollectionConfig, SelectionController } from "./collections";
 import type { FormContext } from "./entity_views";
 import type { User } from "../users";
 import type { RebaseContext } from "../rebase_context";
-import type { SideEntityController } from "../controllers/side_entity_controller";
+import type { SidePanelController } from "../controllers/side_panel_controller";
 /**
- * An entity action is a custom action that can be performed on an entity.
+ * A entity action is a custom action that can be performed on a entity.
  * They are displayed in the entity view and in the collection view.
  */
 export interface EntityAction<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
@@ -61,7 +61,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     entity?: Entity<M>;
     context?: RebaseContext<USER>;
     path?: string;
-    collection?: EntityCollection<M>;
+    collection?: CollectionConfig<M>;
     /**
      * Optional form context, present if the action is being called from a form.
      * This allows you to access the form state and methods, including modifying the form values.
@@ -70,7 +70,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     /**
      * Present if this actions is being called from a side dialog only
      */
-    sideEntityController?: SideEntityController;
+    sidePanelController?: SidePanelController;
     /**
      * Is the action being called from the collection view or from the entity form view?
      */
@@ -94,11 +94,11 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
      */
     unhighlightEntity?: (entity: Entity<Record<string, unknown>>) => void;
     /**
-     * Optional function to navigate back (e.g. when deleting an entity or navigating from a form)
+     * Optional function to navigate back (e.g. when deleting a entity or navigating from a form)
      */
     navigateBack?: () => void;
     /**
-     * Callback to be called when the collection changes, e.g. after an entity is deleted or created.
+     * Callback to be called when the collection changes, e.g. after a entity is deleted or created.
      */
     onCollectionChange?: () => void;
 };

package/dist/types/entity_callbacks.d.ts

@@ -1,12 +1,12 @@
-import type { EntityCollection } from "./collections";
-import type { Entity, EntityStatus, EntityValues } from "./entities";
+import type { CollectionConfig } from "./collections";
+import type { EntityStatus, EntityValues } from "./entities";
 import type { User } from "../users";
 import type { RebaseCallContext } from "../rebase_context";
 /**
  * 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,
+ * via `initializeRebaseBackend({ 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
@@ -14,7 +14,7 @@ import type { RebaseCallContext } from "../rebase_context";
  *
  * @group Models
  */
-export type EntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = {
+export type CollectionCallbacks<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = {
     /**
      * Callback used after fetching data.
      *
@@ -23,88 +23,88 @@ export type EntityCallbacks<M extends Record<string, unknown> = Record<string, u
      *
      * @param props
      */
-    afterRead?(props: EntityAfterReadProps<M, USER>): Promise<Entity<M>> | Entity<M>;
+    afterRead?(props: AfterReadProps<M, USER>): Promise<Record<string, unknown>> | Record<string, unknown>;
     /**
      * Callback used before saving, you need to return the values that will get
      * saved. If you throw an error in this method the process stops, and an
-     * error snackbar gets displayed.
+     * HTTP error response is returned to the client.
      * This runs after schema validation.
      *
      * @param props
      */
-    beforeSave?(props: EntityBeforeSaveProps<M, USER>): Promise<Partial<EntityValues<M>>> | Partial<EntityValues<M>>;
+    beforeSave?(props: BeforeSaveProps<M, USER>): Promise<Partial<EntityValues<M>>> | Partial<EntityValues<M>>;
     /**
      * Callback used when save is successful.
      *
      * @param props
      */
-    afterSave?(props: EntityAfterSaveProps<M, USER>): Promise<void> | void;
+    afterSave?(props: AfterSaveProps<M, USER>): Promise<void> | void;
     /**
      * Callback used when saving fails
      * @param props
      */
-    afterSaveError?(props: EntityAfterSaveErrorProps<M, USER>): Promise<void> | void;
+    afterSaveError?(props: AfterSaveErrorProps<M, USER>): Promise<void> | void;
     /**
      * Callback used before the entity is deleted.
      * If you throw an error in this method the process stops, and an
-     * error snackbar gets displayed.
+     * HTTP error response is returned to the client.
      *
      * @param props
      */
-    beforeDelete?(props: EntityBeforeDeleteProps<M, USER>): Promise<boolean | void> | boolean | void;
+    beforeDelete?(props: BeforeDeleteProps<M, USER>): Promise<boolean | void> | boolean | void;
     /**
      * Callback used after the entity is deleted.
      *
      * @param props
      */
-    afterDelete?(props: EntityAfterDeleteProps<M, USER>): Promise<void> | void;
+    afterDelete?(props: AfterDeleteProps<M, USER>): Promise<void> | void;
 };
 /**
- * Parameters passed to hooks when an entity is fetched
+ * Parameters passed to hooks when a entity is fetched
  * @group Models
  */
-export interface EntityAfterReadProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface AfterReadProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * Collection of the entity
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     /**
      * Full path of the CMS where this collection is being fetched.
      * Might contain unresolved aliases.
      */
     path: string;
     /**
-     * Fetched entity
+     * Fetched row (flat — `{ id, ...columns }`)
      */
-    entity: Entity<M>;
+    row: Record<string, unknown>;
     /**
      * Context of the app status
      */
     context: RebaseCallContext<USER>;
 }
 /**
- * Parameters passed to hooks before an entity is saved
+ * Parameters passed to hooks before a entity is saved
  * @group Models
  */
-export type EntityBeforeSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
-    entityId?: string | number;
+export type BeforeSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = Omit<AfterSaveProps<M, USER>, "id"> & {
+    id?: string | number;
 };
 /**
- * Parameters passed to hooks before an entity is saved
+ * Parameters passed to hooks before a entity is saved
  * @group Models
  */
-export type EntityAfterSaveErrorProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
-    entityId?: string | number;
+export type AfterSaveErrorProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = Omit<AfterSaveProps<M, USER>, "id"> & {
+    id?: string | number;
 };
 /**
- * Parameters passed to hooks when an entity is saved
+ * Parameters passed to hooks when a entity is saved
  * @group Models
  */
-export interface EntityAfterSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface AfterSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * Resolved collection of the entity
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     /**
      * Full path of the CMS where this entity is being saved.
      * Might contain unresolved aliases.
@@ -113,7 +113,7 @@ export interface EntityAfterSaveProps<M extends Record<string, unknown> = Record
     /**
      * ID of the entity
      */
-    entityId: string | number;
+    id: string | number;
     /**
      * Values being saved
      */
@@ -132,14 +132,14 @@ export interface EntityAfterSaveProps<M extends Record<string, unknown> = Record
     context: RebaseCallContext<USER>;
 }
 /**
- * Parameters passed to hooks when an entity is deleted
+ * Parameters passed to hooks when a entity is deleted
  * @group Models
  */
-export interface EntityBeforeDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface BeforeDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * collection of the entity being deleted
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     /**
      * Path of the parent collection
      */
@@ -147,25 +147,25 @@ export interface EntityBeforeDeleteProps<M extends Record<string, unknown> = Rec
     /**
      * Deleted entity id
      */
-    entityId: string | number;
+    id: string | number;
     /**
-     * Deleted entity
+     * Deleted row (flat — `{ id, ...columns }`)
      */
-    entity: Entity<M>;
+    row: Record<string, unknown>;
     /**
      * Context of the app status
      */
     context: RebaseCallContext<USER>;
 }
 /**
- * Parameters passed to hooks after an entity is deleted
+ * Parameters passed to hooks after a entity is deleted
  * @group Models
  */
-export interface EntityAfterDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface AfterDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * collection of the entity being deleted
      */
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     /**
      * Path of the parent collection
      */
@@ -173,11 +173,11 @@ export interface EntityAfterDeleteProps<M extends Record<string, unknown> = Reco
     /**
      * Deleted entity id
      */
-    entityId: string | number;
+    id: string | number;
     /**
-     * Deleted entity
+     * Deleted row (flat — `{ id, ...columns }`)
      */
-    entity: Entity<M>;
+    row: Record<string, unknown>;
     /**
      * Context of the app status
      */

package/dist/types/entity_views.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import type { Entity, EntityValues } from "./entities";
-import type { EntityCollection } from "./collections";
+import type { CollectionConfig } from "./collections";
 import type { FormexController } from "./formex";
 import type { ComponentRef } from "./component_ref";
 /**
@@ -31,7 +31,7 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
     /**
      * Collection of the entity being modified
      */
-    collection?: EntityCollection<M>;
+    collection?: CollectionConfig<M>;
     /**
      * Entity id, it can be undefined if it's a new entity
      */
@@ -86,7 +86,7 @@ export type FormViewConfig<M extends Record<string, unknown> = Record<string, un
     includeActions?: boolean;
 };
 export interface EntityCustomViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
-    collection: EntityCollection<M>;
+    collection: CollectionConfig<M>;
     entity?: Entity<M>;
     modifiedValues?: EntityValues<M>;
     formContext: FormContext<M>;

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

@@ -8,30 +8,55 @@
  * 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    │
- * └──────────────────┴───────────────┴──────────────────────────┘
+ * ┌──────────────────────┬───────────────┬──────────────────────────────┐
+ * │ 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        │
+ * │ "like"               │ "like"        │ SQL LIKE (case-sensitive)    │
+ * │ "ilike"              │ "ilike"       │ SQL ILIKE (case-insensitive) │
+ * │ "not-like"           │ "nlike"       │ NOT LIKE (case-sensitive)    │
+ * │ "not-ilike"          │ "nilike"      │ NOT ILIKE (case-insensitive) │
+ * │ "is-null"            │ "isnull"      │ Field IS NULL                │
+ * │ "is-not-null"        │ "notnull"     │ Field IS NOT NULL            │
+ * └──────────────────────┴───────────────┴──────────────────────────────┘
+ *
+ * Pattern matching (`like`/`ilike`) uses SQL wildcard syntax: `%` matches any
+ * sequence of characters, `_` matches a single character. On MongoDB these are
+ * translated to anchored regular expressions; Firestore has no native pattern
+ * matching and rejects these operators (use `searchString` instead).
  *
  * @module
  */
+/**
+ * Canonical sort representation: `[fieldName, direction]`.
+ *
+ * Used in `FindParams.orderBy`, `collection.sort`, and `FilterPreset.sort`.
+ * The colon-string form (`"field:direction"`) exists only at the HTTP wire
+ * boundary, handled by `serializeOrderBy` / `deserializeOrderBy` in
+ * `@rebasepro/common`.
+ *
+ * Design note: the natural extension for multi-column sort is
+ * `OrderByTuple[]` — not implemented yet (server consumes only the first).
+ *
+ * @group Models
+ */
+export type OrderByTuple<Key extends string = string> = [Key, "asc" | "desc"];
 /**
  * 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";
+export type WhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-contains" | "in" | "not-in" | "array-contains-any" | "like" | "ilike" | "not-like" | "not-ilike" | "is-null" | "is-not-null";
 /**
  * Used to define filters applied in collections.
  *
@@ -49,6 +74,14 @@ export type WhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-conta
  * { role: ["in", ["admin", "editor"]] }
  * { tags: ["array-contains", "featured"] }
  *
+ * // Pattern matching (SQL wildcards: % and _)
+ * { name: ["ilike", "%john%"] }
+ * { slug: ["like", "post-%"] }
+ *
+ * // Null checks (the value is ignored; `null` is conventional)
+ * { deleted_at: ["is-null", null] }
+ * { published_at: ["is-not-null", null] }
+ *
  * @group Models
  */
 export type FilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, unknown] | [WhereFilterOp, unknown][]>>;
@@ -83,18 +116,30 @@ export interface FilterPreset<Key extends string = string> {
     /**
      * Optional sort override to apply alongside the filter values.
      */
-    sort?: [Key, "asc" | "desc"];
+    sort?: OrderByTuple<Key>;
 }
 /**
  * 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";
+export type RestFilterOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "cs" | "csa" | "like" | "ilike" | "nlike" | "nilike" | "isnull" | "notnull";
 /** 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>>;
+/**
+ * Operators that test for null/not-null and therefore ignore their value.
+ * Codecs normalize the value of these conditions to `null`.
+ */
+export declare const NULL_OPS: ReadonlySet<WhereFilterOp>;
+/**
+ * Every canonical operator, in a stable order. Useful for engine capability
+ * declarations ({@link DataSourceCapabilities.filterOperators}) and for
+ * building operator subsets.
+ * @group Models
+ */
+export declare const ALL_WHERE_FILTER_OPS: readonly WhereFilterOp[];
 /**
  * Resolve any operator string (canonical or REST short-code) to its
  * canonical `WhereFilterOp` form. Returns `undefined` for unknown operators.

package/dist/types/modify_collections.d.ts

@@ -1,5 +1,5 @@
-import { EntityCollection } from "./collections";
+import { CollectionConfig } from "./collections";
 export type ModifyCollectionProps = {
-    collection: EntityCollection;
+    collection: CollectionConfig;
     parentPaths: string[];
 };