@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.5584634

package/dist/server-postgresql/src/services/EntityFetchService.d.ts

@@ -22,7 +22,12 @@ export declare class EntityFetchService {
      * Build filter conditions from FilterValues
      * Delegates to DrizzleConditionBuilder.buildFilterConditions
      */
-    buildFilterConditions<M extends Record<string, any>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
+    buildFilterConditions<M extends Record<string, unknown>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
+    /**
+     * Resolves the correct Drizzle column for sorting.
+     * Automatically maps owning relation property keys to their underlying foreign key column.
+     */
+    private resolveOrderByField;
     /**
      * Build the `with` config for Drizzle's relational query API.
      * Converts collection relations to a Drizzle-compatible `with` object.
@@ -63,6 +68,11 @@ export declare class EntityFetchService {
      * Uses batch fetching to avoid N+1 queries for list views.
      */
     private resolveJoinPathRelationsBatch;
+    /**
+     * Resolves joinPath relations for raw REST rows and directly injects them.
+     * Uses RelationService to query the database and maps results back to the flattened objects.
+     */
+    private resolveJoinPathRelationsBatchRest;
     /**
      * Convert a db.query result row to a flat REST-style object with populated relations.
      */
@@ -79,15 +89,16 @@ export declare class EntityFetchService {
     /**
      * Fetch a single entity by ID
      */
-    fetchEntity<M extends Record<string, any>>(collectionPath: string, entityId: string | number, databaseId?: string): Promise<Entity<M> | undefined>;
+    fetchEntity<M extends Record<string, unknown>>(collectionPath: string, entityId: string | number, databaseId?: string): Promise<Entity<M> | undefined>;
     /**
      * Unified method to fetch entities with optional search functionality
      */
-    fetchEntitiesWithConditions<M extends Record<string, any>>(collectionPath: string, options?: {
+    fetchEntitiesWithConditions<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
         limit?: number;
+        offset?: number;
         startAfter?: Record<string, unknown>;
         searchString?: string;
         databaseId?: string;
@@ -103,11 +114,12 @@ export declare class EntityFetchService {
     /**
      * Fetch a collection of entities
      */
-    fetchCollection<M extends Record<string, any>>(collectionPath: string, options?: {
+    fetchCollection<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
         limit?: number;
+        offset?: number;
         startAfter?: Record<string, unknown>;
         searchString?: string;
         databaseId?: string;
@@ -115,7 +127,7 @@ export declare class EntityFetchService {
     /**
      * Search entities by text
      */
-    searchEntities<M extends Record<string, any>>(collectionPath: string, searchString: string, options?: {
+    searchEntities<M extends Record<string, unknown>>(collectionPath: string, searchString: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -129,8 +141,9 @@ export declare class EntityFetchService {
     /**
      * Count entities in a collection
      */
-    countEntities<M extends Record<string, any>>(collectionPath: string, options?: {
+    countEntities<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
+        searchString?: string;
         databaseId?: string;
     }): Promise<number>;
     /**
@@ -153,11 +166,12 @@ export declare class EntityFetchService {
      *
      * @param include - Array of relation keys to populate, or ["*"] for all
      */
-    fetchCollectionForRest<M extends Record<string, any>>(collectionPath: string, options?: {
+    fetchCollectionForRest<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
         limit?: number;
+        offset?: number;
         startAfter?: Record<string, unknown>;
         searchString?: string;
         databaseId?: string;
@@ -165,7 +179,7 @@ export declare class EntityFetchService {
     /**
      * Fetch a single entity with optional relation includes for REST API.
      */
-    fetchEntityForRest<M extends Record<string, any>>(collectionPath: string, entityId: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
+    fetchEntityForRest<M extends Record<string, unknown>>(collectionPath: string, entityId: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
     /**
      * Fetch raw rows without any relation processing (for REST fast path)
      */

package/dist/server-postgresql/src/services/EntityPersistService.d.ts

@@ -20,7 +20,7 @@ export declare class EntityPersistService {
     /**
      * Save an entity (create or update)
      */
-    saveEntity<M extends Record<string, any>>(collectionPath: string, values: Partial<M>, entityId?: string | number, databaseId?: string): Promise<Entity<M>>;
+    saveEntity<M extends Record<string, unknown>>(collectionPath: string, values: Partial<M>, entityId?: string | number, databaseId?: string): Promise<Entity<M>>;
     /**
      * Get the RelationService instance for external use
      */

package/dist/server-postgresql/src/services/RelationService.d.ts

@@ -12,7 +12,7 @@ export declare class RelationService {
     /**
      * Fetch entities related to a parent entity through a specific relation
      */
-    fetchRelatedEntities<M extends Record<string, any>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
+    fetchRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -24,7 +24,7 @@ export declare class RelationService {
     /**
      * Fetch entities using join paths for complex relations
      */
-    fetchEntitiesUsingJoins<M extends Record<string, any>>(parentCollection: EntityCollection, parentEntityId: string | number, relation: Relation, options?: {
+    fetchEntitiesUsingJoins<M extends Record<string, unknown>>(parentCollection: EntityCollection, parentEntityId: string | number, relation: Relation, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -36,18 +36,24 @@ export declare class RelationService {
     /**
      * Count related entities for a parent entity
      */
-    countRelatedEntities<M extends Record<string, any>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
+    countRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         databaseId?: string;
     }): Promise<number>;
     /**
      * Batch fetch related entities for multiple parent entities to avoid N+1 queries
      */
-    batchFetchRelatedEntities(parentCollectionPath: string, parentEntityIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string | number, Entity<Record<string, unknown>>>>;
+    batchFetchRelatedEntities(parentCollectionPath: string, parentEntityIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, Entity<Record<string, unknown>>>>;
+    /**
+     * Batch fetch many-cardinality related entities for multiple parent entities.
+     * Returns a Map<parentId, Entity[]> instead of Map<parentId, Entity>.
+     * Uses a single SQL query with IN clause to avoid N+1.
+     */
+    batchFetchRelatedEntitiesMany(parentCollectionPath: string, parentEntityIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, Entity<Record<string, unknown>>[]>>;
     /**
      * Update many-to-many and junction relations
      */
-    updateRelationsUsingJoins<M extends Record<string, any>>(tx: DrizzleClient, collection: EntityCollection, entityId: string | number, relationValues: Partial<M>): Promise<void>;
+    updateRelationsUsingJoins<M extends Record<string, unknown>>(tx: DrizzleClient, collection: EntityCollection, entityId: string | number, relationValues: Partial<M>): Promise<void>;
     /**
      * Update inverse relations (where FK is on the target table)
      */

package/dist/server-postgresql/src/services/entity-helpers.d.ts

@@ -1,4 +1,4 @@
-import { PgTable } from "drizzle-orm/pg-core";
+import { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
 import { EntityCollection } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 /**
@@ -8,17 +8,31 @@ import { PostgresCollectionRegistry } from "../collections/PostgresCollectionReg
  * All functions that need collection/table lookups require an explicit
  * `PostgresCollectionRegistry` instance — there is no global singleton.
  */
+/**
+ * Interface for Drizzle column metadata introspection.
+ * Replaces unsafe `as unknown as Record<string, unknown>` double-cast chains.
+ */
+export interface DrizzleColumnMeta {
+    columnType?: string;
+    dataType?: string;
+    primary?: boolean;
+}
+/** Safely extract Drizzle column metadata from a column object. */
+export declare function getColumnMeta(col: AnyPgColumn): DrizzleColumnMeta;
 export declare function getCollectionByPath(collectionPath: string, registry: PostgresCollectionRegistry): EntityCollection;
 export declare function getTableForCollection(collection: EntityCollection, registry: PostgresCollectionRegistry): PgTable<any>;
 export declare function getPrimaryKeys(collection: EntityCollection, registry: PostgresCollectionRegistry): {
     fieldName: string;
     type: "string" | "number";
+    isUUID?: boolean;
 }[];
 export declare function parseIdValues(idValue: string | number, primaryKeys: {
     fieldName: string;
     type: "string" | "number";
+    isUUID?: boolean;
 }[]): Record<string, string | number>;
-export declare function buildCompositeId(values: Record<string, any>, primaryKeys: {
+export declare function buildCompositeId(values: Record<string, unknown>, primaryKeys: {
     fieldName: string;
     type: "string" | "number";
+    isUUID?: boolean;
 }[]): string;

package/dist/server-postgresql/src/services/entityService.d.ts

@@ -29,15 +29,16 @@ export declare class EntityService implements EntityRepository {
     /**
      * Fetch a single entity by ID
      */
-    fetchEntity<M extends Record<string, any>>(collectionPath: string, entityId: string | number, databaseId?: string): Promise<Entity<M> | undefined>;
+    fetchEntity<M extends Record<string, unknown>>(collectionPath: string, entityId: string | number, databaseId?: string): Promise<Entity<M> | undefined>;
     /**
      * Fetch a collection of entities with optional filtering, ordering, and pagination
      */
-    fetchCollection<M extends Record<string, any>>(collectionPath: string, options?: {
+    fetchCollection<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
         limit?: number;
+        offset?: number;
         startAfter?: Record<string, unknown>;
         searchString?: string;
         databaseId?: string;
@@ -45,7 +46,7 @@ export declare class EntityService implements EntityRepository {
     /**
      * Search entities by text
      */
-    searchEntities<M extends Record<string, any>>(collectionPath: string, searchString: string, options?: {
+    searchEntities<M extends Record<string, unknown>>(collectionPath: string, searchString: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -55,8 +56,9 @@ export declare class EntityService implements EntityRepository {
     /**
      * Count entities in a collection
      */
-    countEntities<M extends Record<string, any>>(collectionPath: string, options?: {
+    countEntities<M extends Record<string, unknown>>(collectionPath: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
+        searchString?: string;
         databaseId?: string;
     }): Promise<number>;
     /**
@@ -66,7 +68,7 @@ export declare class EntityService implements EntityRepository {
     /**
      * Fetch entities related to a parent entity
      */
-    fetchRelatedEntities<M extends Record<string, any>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
+    fetchRelatedEntities<M extends Record<string, unknown>>(parentCollectionPath: string, parentEntityId: string | number, relationKey: string, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -78,7 +80,7 @@ export declare class EntityService implements EntityRepository {
     /**
      * Save an entity (create or update)
      */
-    saveEntity<M extends Record<string, any>>(collectionPath: string, values: Partial<M>, entityId?: string | number, databaseId?: string): Promise<Entity<M>>;
+    saveEntity<M extends Record<string, unknown>>(collectionPath: string, values: Partial<M>, entityId?: string | number, databaseId?: string): Promise<Entity<M>>;
     /**
      * Delete an entity by ID
      */

package/dist/server-postgresql/src/services/realtimeService.d.ts

@@ -55,6 +55,7 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;
+            offset?: number;
             startAfter?: Record<string, unknown>;
             databaseId?: string;
             searchString?: string;
@@ -71,6 +72,7 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;
+            offset?: number;
             startAfter?: Record<string, unknown>;
             databaseId?: string;
             searchString?: string;

package/dist/server-postgresql/src/utils/drizzle-conditions.d.ts

@@ -21,7 +21,7 @@ export declare class DrizzleConditionBuilder {
     /**
      * Build filter conditions from FilterValues
      */
-    static buildFilterConditions<M extends Record<string, any>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
+    static buildFilterConditions<M extends Record<string, unknown>>(filter: FilterValues<Extract<keyof M, string>>, table: PgTable<any>, collectionPath: string): SQL[];
     /**
      * Build a single filter condition for a specific operator and value
      */
@@ -71,7 +71,7 @@ export declare class DrizzleConditionBuilder {
     /**
      * Build search conditions for text fields
      */
-    static buildSearchConditions(searchString: string, properties: Record<string, any>, table: PgTable<any>): SQL[];
+    static buildSearchConditions(searchString: string, properties: Record<string, unknown>, table: PgTable<any>): SQL[];
     /**
      * Build a unique field check condition
      */

package/dist/types/src/controllers/auth.d.ts

@@ -15,6 +15,8 @@ export interface AuthCapabilities {
     sessionManagement?: boolean;
     profileUpdate?: boolean;
     emailVerification?: boolean;
+    /** List of enabled OAuth provider IDs (e.g. ["google", "github", "discord"]) */
+    enabledProviders?: string[];
 }
 /**
  * Controller for retrieving the logged user or performing auth related operations.

package/dist/types/src/controllers/client.d.ts

@@ -1,9 +1,10 @@
 import { User } from "../users";
 import { RebaseData } from "./data";
+import { EmailService } from "./email";
 /**
  * Event type for authentication state changes
  */
-export type AuthChangeEvent = 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED';
+export type AuthChangeEvent = "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "USER_UPDATED";
 /**
  * Standard session interface representing an authenticated state
  */
@@ -39,20 +40,131 @@ export interface AuthClient {
      * Manually refresh the session token
      */
     refreshSession(): Promise<RebaseSession>;
-    [key: string]: any;
 }
 /**
- * Overarching abstraction that unites Data, Auth, and Storage.
+ * User record as returned by the Admin API.
+ * @group Admin
+ */
+export interface AdminUser {
+    uid: string;
+    email: string;
+    displayName: string | null;
+    photoURL: string | null;
+    provider: string;
+    roles: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Role record as returned by the Admin API.
+ * @group Admin
+ */
+export interface AdminRole {
+    id: string;
+    name: string;
+    isAdmin: boolean;
+    defaultPermissions: Record<string, unknown> | null;
+    config: Record<string, unknown> | null;
+}
+/**
+ * Client-side Admin API interface.
+ * Provides user and role management operations.
+ * @group Admin
+ */
+export interface AdminAPI {
+    listUsers(): Promise<{
+        users: AdminUser[];
+    }>;
+    listUsersPaginated(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDir?: "asc" | "desc";
+    }): Promise<{
+        users: AdminUser[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getUser(userId: string): Promise<{
+        user: AdminUser;
+    }>;
+    createUser(data: {
+        email: string;
+        displayName?: string;
+        password?: string;
+        roles?: string[];
+    }): Promise<{
+        user: AdminUser;
+    }>;
+    updateUser(userId: string, data: {
+        email?: string;
+        displayName?: string;
+        password?: string;
+        roles?: string[];
+    }): Promise<{
+        user: AdminUser;
+    }>;
+    deleteUser(userId: string): Promise<{
+        success: boolean;
+    }>;
+    listRoles(): Promise<{
+        roles: AdminRole[];
+    }>;
+    getRole(roleId: string): Promise<{
+        role: AdminRole;
+    }>;
+    createRole(data: {
+        id: string;
+        name: string;
+        isAdmin?: boolean;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }): Promise<{
+        role: AdminRole;
+    }>;
+    updateRole(roleId: string, data: {
+        name?: string;
+        isAdmin?: boolean;
+        defaultPermissions?: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }): Promise<{
+        role: AdminRole;
+    }>;
+    deleteRole(roleId: string): Promise<{
+        success: boolean;
+    }>;
+    bootstrap(): Promise<{
+        success: boolean;
+        message: string;
+        user: {
+            uid: string;
+            roles: string[];
+        };
+    }>;
+}
+/**
+ * Overarching abstraction that unites Data, Auth, Storage, and Email.
  * Adapters for Supabase or Firebase simply need to implement this interface.
  */
-export interface RebaseClient<DB = any> {
+export interface RebaseClient<DB = unknown> {
     /** Unified Data access layer */
     data: RebaseData;
     /** Unified Authentication layer */
     auth: AuthClient;
     /** Unified Storage layer */
     storage?: StorageSource;
-    /** Optional admin panel specific tasks */
-    admin?: any;
-    [key: string]: any;
+    /**
+     * Server-side email service.
+     *
+     * Available when SMTP (or a custom `sendEmail` function) is configured
+     * in the backend auth config. `undefined` when email is not configured.
+     *
+     * > **Note:** This is only available on the server-side `rebase` singleton.
+     * > The client-side SDK does not include an email service.
+     */
+    email?: EmailService;
+    /** Admin API for user and role management */
+    admin?: AdminAPI;
 }

package/dist/types/src/controllers/collection_registry.d.ts

@@ -1,9 +1,10 @@
-import { EntityCollection, EntityReference } from "../types";
+import type { EntityCollection } from "../types/collections";
+import type { EntityReference } from "../types/entities";
 /**
  * Controller that provides access to the registered entity collections.
  * @group Models
  */
-export type CollectionRegistryController<EC extends EntityCollection = EntityCollection<any>> = {
+export type CollectionRegistryController<DB = Record<string, unknown>, EC extends EntityCollection = EntityCollection<any>> = {
     /**
      * List of the mapped collections in the CMS.
      * Each entry relates to a collection in the root database.
@@ -19,7 +20,7 @@ export type CollectionRegistryController<EC extends EntityCollection = EntityCol
      * Get the collection configuration for a given path.
      * The collection is resolved from the given path or alias.
      */
-    getCollection: (slugOrPath: string, includeUserOverride?: boolean) => EC | undefined;
+    getCollection: <K extends keyof DB>(slugOrPath: Extract<K, string>, includeUserOverride?: boolean) => EC | undefined;
     /**
      * Get the raw, un-normalized collection configuration.
      * This bypasses the `CollectionRegistry` normalization (such as injecting `relation` instances).

package/dist/types/src/controllers/customization_controller.d.ts

@@ -1,5 +1,11 @@
 import React from "react";
-import { EntityLinkBuilder, Locale, EntityAction, EntityCustomView, RebasePlugin, PropertyConfig, SlotContribution } from "../types";
+import type { EntityLinkBuilder } from "../types/entity_link_builder";
+import type { Locale } from "../types/locales";
+import type { EntityAction } from "../types/entity_actions";
+import type { EntityCustomView } from "../types/entity_views";
+import type { RebasePlugin } from "../types/plugins";
+import type { PropertyConfig } from "../types/property_config";
+import type { SlotContribution } from "../types/slots";
 export type CustomizationController = {
     /**
      * Builder for generating utility links for entities

package/dist/types/src/controllers/data.d.ts

@@ -6,6 +6,19 @@ import { Entity, EntityValues } from "../types/entities";
  *
  * @group Data
  */
+/**
+ * A where-clause value for a single field.
+ *
+ * Supports three syntaxes:
+ *  1. **Equality shorthand**: raw JS values — `null`, `"active"`, `42`, `true`
+ *  2. **Tuple syntax**: `[operator, value]` — `[">", 18]`, `["in", ["a","b"]]`
+ *  3. **PostgREST string**: `"eq.published"`, `"gte.18"`, `"in.(a,b)"`
+ *
+ * @group Data
+ */
+export type WhereFieldValue = string | number | boolean | null | [WhereFilterOpShort, any];
+/** Short operator strings accepted in the tuple syntax. */
+export type WhereFilterOpShort = "==" | "!=" | ">" | ">=" | "<" | "<=" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "not-in" | "array-contains" | "array-contains-any" | "cs" | "csa";
 export interface FindParams {
     /** Maximum number of items to return (default: 20) */
     limit?: number;
@@ -14,16 +27,30 @@ export interface FindParams {
     /** Page number (1-indexed), alternative to offset */
     page?: number;
     /**
-     * PostgREST-style filter object.
-     * Keys are field names, values use "operator.value" format.
-     * Operators: eq, neq, gt, gte, lt, lte, in, nin, cs (array-contains), csa (array-contains-any)
+     * Filter object. Supports multiple syntaxes per field:
      *
-     * @example
+     * **Equality shorthand** — raw JS values (null, string, number, boolean):
+     * ```ts
+     * { company_profile_id: null }
+     * { status: "active" }
+     * { age: 18 }
+     * ```
+     *
+     * **Tuple syntax** — `[operator, value]`:
+     * ```ts
+     * { age: [">=", 18] }
+     * { role: ["in", ["admin", "editor"]] }
+     * { deleted_at: ["!=", null] }
+     * ```
+     *
+     * **PostgREST string syntax** (original format):
+     * ```ts
      * { status: "eq.published" }
      * { age: "gte.18" }
      * { role: "in.(admin,editor)" }
+     * ```
      */
-    where?: Record<string, string>;
+    where?: Record<string, WhereFieldValue>;
     /**
      * Sort order. Format: "field:direction".
      * @example "created_at:desc", "name:asc"
@@ -38,7 +65,7 @@ export interface FindParams {
  * Paginated response from a collection query.
  * @group Data
  */
-export interface FindResponse<M extends Record<string, any> = any> {
+export interface FindResponse<M extends Record<string, unknown> = Record<string, unknown>> {
     /** Array of entities matching the query */
     data: Entity<M>[];
     /** Pagination metadata */
@@ -58,7 +85,7 @@ export interface FindResponse<M extends Record<string, any> = any> {
  *
  * @group Data
  */
-export interface CollectionAccessor<M extends Record<string, any> = any> {
+export interface CollectionAccessor<M extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * Find multiple records with optional filtering, pagination, and sorting.
      */