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

package/dist/types/src/types/collections.d.ts

@@ -1,14 +1,14 @@
 import React from "react";
-import { Entity, EntityStatus } from "./entities";
-import { EntityCallbacks } from "./entity_callbacks";
-import { Properties } from "./properties";
-import { ExportConfig } from "./export_import";
-import { EntityOverrides } from "./entity_overrides";
-import { User } from "../users";
-import { RebaseContext } from "../rebase_context";
-import { Relation } from "./relations";
-import { EntityCustomView } from "./entity_views";
-import { EntityAction } from "./entity_actions";
+import type { Entity, EntityStatus } from "./entities";
+import type { EntityCallbacks } from "./entity_callbacks";
+import type { Properties } 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 } from "./entity_views";
+import type { EntityAction } from "./entity_actions";
 /**
  * Base interface containing all driver-agnostic collection properties.
  * Use {@link PostgresCollection} or {@link FirebaseCollection} for
@@ -98,6 +98,11 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Default preview properties displayed when this collection is referenced to.
      */
     previewProperties?: string[];
+    /**
+     * Properties to display as columns in the list view.
+     * If not specified, the list view uses a smart default (Title, Status, Date).
+     */
+    listProperties?: string[];
     /**
      * Title property of the entity. This is the property that will be used
      * as the title in entity related views and references.
@@ -108,7 +113,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * When editing an 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";
+    openEntityMode?: "side_panel" | "full_screen" | "split";
     /**
      * Order in which the properties are displayed.
      * If you are specifying your collection as code, the order is the same as the
@@ -262,7 +267,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     localChangesBackup?: "manual_apply" | "auto_apply" | false;
     /**
      * Default view mode for displaying this collection.
-     * - "table": Display entities in a spreadsheet-like table (default)
+     * - "table": Display entities in a table with inline editing (default)
      * - "cards": Display entities as a grid of cards with thumbnails
      * - "kanban": Display entities in a Kanban board grouped by a property
      * Defaults to "table".
@@ -283,9 +288,10 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     kanban?: KanbanConfig<M>;
     /**
      * Property key to use for ordering items.
-     * Must reference a number property. When items are reordered,
-     * this property will be updated to reflect the new order using
-     * fractional indexing. Used by Kanban view for ordering within columns
+     * Must reference a string/text property. When items are reordered,
+     * this property will be updated with lexicographic sort keys
+     * (e.g. "a0", "a1", "a0V") using string-based fractional indexing.
+     * Used by Kanban view for ordering within columns
      * and can be used for general ordering purposes.
      */
     readonly orderProperty?: Extract<keyof M, string> | (string & {});
@@ -317,11 +323,6 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
      * The PostgreSQL table name for this collection.
      */
     table: string;
-    /**
-     * Set by the backend when the resolved table name doesn't match
-     * an actual table in the database schema.
-     */
-    isTableMissing?: boolean;
     /**
      * For SQL databases, you can define the relations between collections here.
      * Relations describe JOINs, foreign keys, and junction tables.
@@ -365,14 +366,39 @@ export interface FirebaseCollection<M extends Record<string, unknown> = Record<s
      */
     subcollections?: () => EntityCollection<Record<string, unknown>>[];
 }
+/**
+ * A collection backed by MongoDB.
+ *
+ * Use this type instead of {@link EntityCollection} 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> {
+    /**
+     * The driver for this collection. Must be set to `"mongodb"`.
+     */
+    driver: "mongodb";
+}
 /**
  * A collection backed by any data source.
- * This is a discriminated union — use {@link PostgresCollection} or
- * {@link FirebaseCollection} for driver-specific type safety.
+ * This is a discriminated union — use {@link PostgresCollection},
+ * {@link FirebaseCollection}, or {@link MongoDBCollection} 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>;
+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). */
+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).
@@ -384,6 +410,11 @@ export declare function isPostgresCollection<M extends Record<string, unknown> =
  * @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>;
+/**
+ * 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>;
 /**
  * Configuration for Kanban board view mode.
  * @group Collections
@@ -399,9 +430,13 @@ export interface KanbanConfig<M extends Record<string, unknown> = Record<string,
 }
 /**
  * View mode for displaying a collection.
+ * - "list": Simple, clean list view — the classic CMS default
+ * - "table": Table with inline editing
+ * - "cards": Grid of visual cards with thumbnails
+ * - "kanban": Board view grouped by a property
  * @group Collections
  */
-export type ViewMode = "table" | "cards" | "kanban";
+export type ViewMode = "list" | "table" | "cards" | "kanban";
 /**
  * Parameter passed to the `Actions` prop in the collection configuration.
  * The component will receive this prop when it is rendered in the collection
@@ -610,9 +645,18 @@ 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.
+ *
  * @group Models
  */
-export interface SecurityRule {
+export type SecurityRule = OwnerSecurityRule | PublicSecurityRule | RawSQLSecurityRule | RolesOnlySecurityRule;
+/**
+ * Shared fields for all SecurityRule variants.
+ * @group Models
+ */
+export interface SecurityRuleBase {
     /**
      * Optional human-readable name for the policy.
      * If not provided, one will be auto-generated from the table name and operation.
@@ -664,35 +708,6 @@ export interface SecurityRule {
      * @default "permissive"
      */
     mode?: "permissive" | "restrictive";
-    /**
-     * **Shortcut.** The property (column) that stores the owner's user ID.
-     * Generates a USING/WITH CHECK clause like:
-     *   `<column> = auth.uid()`
-     *
-     * Cannot be combined with `using` / `withCheck` / `access`.
-     *
-     * @example
-     * { operation: "all", ownerField: "user_id" }
-     */
-    ownerField?: string;
-    /**
-     * **Shortcut.** Grant unrestricted row access (no row filtering) for this operation.
-     * Generates `USING (true)`.
-     *
-     * This means "no row-level filter", NOT "anonymous/unauthenticated access".
-     * Authentication is still enforced at the API layer — this only controls which
-     * *rows* authenticated users can see.
-     *
-     * Typically used alone for genuinely public read endpoints, or combined with
-     * `roles` to give certain roles an unfiltered view of the table.
-     *
-     * Cannot be combined with `using` / `withCheck` / `ownerField`.
-     *
-     * @example
-     * // Public read (any authenticated user sees all rows)
-     * { operation: "select", access: "public" }
-     */
-    access?: "public";
     /**
      * **Shortcut.** Restrict this rule to users that have one of these
      * application-level roles.
@@ -716,77 +731,6 @@ export interface SecurityRule {
      * { operation: "select", roles: ["admin"], using: "true" }
      */
     roles?: string[];
-    /**
-     * Raw SQL expression for the `USING` clause.
-     * This controls which *existing* rows are visible / can be modified / deleted.
-     * Applied to SELECT, UPDATE, and DELETE.
-     *
-     * You can reference columns via `{column_name}` which will be resolved to
-     * `table.column_name` in the generated Drizzle code. You can also use any
-     * valid PostgreSQL expression.
-     *
-     * Cannot be combined with `ownerField` or `access`.
-     *
-     * @example
-     * // Rows published in the last 30 days are visible
-     * { operation: "select", using: "{published_at} > now() - interval '30 days'" }
-     *
-     * @example
-     * // Only the owner, or users with 'moderator' role
-     * {
-     *   operation: "select",
-     *   using: "{user_id} = auth.uid() OR auth.roles() ~ 'moderator'"
-     * }
-     *
-     * @example
-     * // Cross-table subquery: only if user belongs to the org
-     * {
-     *   operation: "select",
-     *   using: "EXISTS (SELECT 1 FROM org_members WHERE org_members.org_id = {org_id} AND org_members.user_id = auth.uid())"
-     * }
-     */
-    using?: string;
-    /**
-     * Raw SQL expression for the `WITH CHECK` clause.
-     * This controls which *new/updated* row values are allowed.
-     * Applied to INSERT and UPDATE.
-     *
-     * Same syntax as `using` — use `{column_name}` to reference columns.
-     *
-     * **Important for UPDATE:** PostgreSQL evaluates two row states — the
-     * *existing* row (`USING`) and the *incoming new* row (`WITH CHECK`).
-     * If you only specify `using`, the same expression is used for both.
-     * For security-sensitive updates, always specify `withCheck` explicitly
-     * to constrain what the new row values can be.
-     *
-     * If not provided on INSERT/UPDATE policies, falls back to `using`
-     * (which matches PostgreSQL's own default behavior).
-     *
-     * Cannot be combined with `ownerField` or `access`.
-     *
-     * @example
-     * // Users can only insert rows where they are the owner
-     * { operation: "insert", withCheck: "{user_id} = auth.uid()" }
-     *
-     * @example
-     * // Prevent changing the status to 'archived' unless admin
-     * {
-     *   operation: "update",
-     *   using: "{user_id} = auth.uid()",
-     *   withCheck: "{status} != 'archived' OR auth.roles() ~ 'admin'"
-     * }
-     *
-     * @example
-     * // Restrictive gate: prevent locking AND unlocking unless admin.
-     * // `using` checks the old row state, `withCheck` checks the new.
-     * {
-     *   operation: "update",
-     *   mode: "restrictive",
-     *   using: "{is_locked} = false",
-     *   withCheck: "{is_locked} = false"
-     * }
-     */
-    withCheck?: string;
     /**
      * **Advanced.** Native PostgreSQL database roles the policy applies to.
      *
@@ -810,3 +754,103 @@ export interface SecurityRule {
      */
     pgRoles?: string[];
 }
+/**
+ * Security rule that grants access based on row ownership.
+ * Generates a USING/WITH CHECK clause like: `<column> = auth.uid()`
+ *
+ * Cannot be combined with `using`, `withCheck`, or `access`.
+ *
+ * @example
+ * { operation: "all", ownerField: "user_id" }
+ *
+ * @group Models
+ */
+export interface OwnerSecurityRule extends SecurityRuleBase {
+    /** The property (column) that stores the owner's user ID. */
+    ownerField: string;
+    access?: never;
+    using?: never;
+    withCheck?: never;
+}
+/**
+ * Security rule that grants unrestricted row access (no row filtering).
+ * Generates `USING (true)`.
+ *
+ * This means "no row-level filter", NOT "anonymous/unauthenticated access".
+ * Authentication is still enforced at the API layer — this only controls which
+ * *rows* authenticated users can see.
+ *
+ * Cannot be combined with `using`, `withCheck`, or `ownerField`.
+ *
+ * @example
+ * // Public read (any authenticated user sees all rows)
+ * { operation: "select", access: "public" }
+ *
+ * @group Models
+ */
+export interface PublicSecurityRule extends SecurityRuleBase {
+    /** Grant unrestricted row access for this operation. */
+    access: "public";
+    ownerField?: never;
+    using?: never;
+    withCheck?: never;
+}
+/**
+ * Security rule using raw SQL expressions for full PostgreSQL RLS power.
+ *
+ * Cannot be combined with `ownerField` or `access`.
+ *
+ * You can reference columns via `{column_name}` which will be resolved to
+ * `table.column_name` in the generated Drizzle code.
+ *
+ * @example
+ * // Rows published in the last 30 days are visible
+ * { operation: "select", using: "{published_at} > now() - interval '30 days'" }
+ *
+ * @example
+ * // Only the owner, or users with 'moderator' role
+ * {
+ *   operation: "select",
+ *   using: "{user_id} = auth.uid() OR auth.roles() ~ 'moderator'"
+ * }
+ *
+ * @group Models
+ */
+export interface RawSQLSecurityRule extends SecurityRuleBase {
+    /**
+     * Raw SQL expression for the `USING` clause.
+     * This controls which *existing* rows are visible / can be modified / deleted.
+     * Applied to SELECT, UPDATE, and DELETE.
+     */
+    using: string;
+    /**
+     * Raw SQL expression for the `WITH CHECK` clause.
+     * This controls which *new/updated* row values are allowed.
+     * Applied to INSERT and UPDATE.
+     *
+     * If not provided on INSERT/UPDATE policies, falls back to `using`
+     * (which matches PostgreSQL's own default behavior).
+     */
+    withCheck?: string;
+    ownerField?: never;
+    access?: never;
+}
+/**
+ * Security rule that only filters by application roles, without any
+ * row-level condition (USING/WITH CHECK).
+ *
+ * Useful for simple "only admins can access this table" rules where
+ * no per-row filtering is needed.
+ *
+ * @example
+ * // Only admins can delete
+ * { operation: "delete", roles: ["admin"] }
+ *
+ * @group Models
+ */
+export interface RolesOnlySecurityRule extends SecurityRuleBase {
+    ownerField?: never;
+    access?: never;
+    using?: never;
+    withCheck?: never;
+}

package/dist/types/src/types/cron.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Cron Job type definitions for Rebase.
+ *
+ * These types define the shape of cron job definitions, their runtime
+ * status, and execution log entries — used across server-core, client,
+ * and studio packages.
+ */
+/**
+ * A cron job definition file exports this shape as its default export.
+ * See the example cron files in `app/backend/crons/` for usage.
+ */
+export interface CronJobDefinition {
+    schedule: string;
+    /** Human-readable name shown in the Studio UI. */
+    name: string;
+    /** Optional description shown in the Studio UI. */
+    description?: string;
+    /**
+     * Whether the job is enabled at startup. Defaults to `true`.
+     * Can be toggled at runtime via the Admin API.
+     */
+    enabled?: boolean;
+    /**
+     * Maximum number of seconds the handler may run before being
+     * considered timed-out. Default: 300 (5 min).
+     */
+    timeoutSeconds?: number;
+    /**
+     * The handler function executed on each tick.
+     * Receives a context object with the data driver and logger.
+     * May return arbitrary JSON-serialisable data stored in the log.
+     */
+    handler: (ctx: CronJobContext) => Promise<unknown> | unknown;
+}
+import type { RebaseClient } from "../controllers/client";
+/**
+ * Context passed to each cron handler invocation.
+ */
+export interface CronJobContext {
+    /** The job's unique ID (derived from filename). */
+    jobId: string;
+    /** The current scheduled tick timestamp. */
+    scheduledAt: Date;
+    /** A simple logger scoped to this job run. */
+    log: (...args: unknown[]) => void;
+    /** The RebaseClient instance to interact with the database. */
+    client: RebaseClient<any>;
+}
+export type CronJobRunState = "idle" | "running" | "success" | "error" | "disabled";
+/**
+ * Full runtime information about a registered cron job.
+ */
+export interface CronJobStatus {
+    /** Unique identifier (derived from filename, e.g. "cleanup-sessions"). */
+    id: string;
+    /** Human-readable name from the definition. */
+    name: string;
+    /** Description from the definition. */
+    description?: string;
+    /** The cron schedule expression. */
+    schedule: string;
+    /** Whether the job is currently enabled. */
+    enabled: boolean;
+    /** Current run state. */
+    state: CronJobRunState;
+    /** ISO timestamp of the last execution start. */
+    lastRunAt?: string;
+    /** ISO timestamp of the next scheduled execution. */
+    nextRunAt?: string;
+    /** Duration of the last run in milliseconds. */
+    lastDurationMs?: number;
+    /** Error message from the last failed run. */
+    lastError?: string;
+    /** Total number of executions since server start. */
+    totalRuns: number;
+    /** Total number of failed executions since server start. */
+    totalFailures: number;
+}
+export type CronLogLevel = "info" | "error" | "warn";
+/**
+ * A single execution log entry stored in the in-memory ring buffer.
+ */
+export interface CronJobLogEntry {
+    /** The job ID this log belongs to. */
+    jobId: string;
+    /** ISO timestamp when execution started. */
+    startedAt: string;
+    /** ISO timestamp when execution finished. */
+    finishedAt: string;
+    /** Duration in milliseconds. */
+    durationMs: number;
+    /** Whether this run succeeded. */
+    success: boolean;
+    /** Error message if the run failed. */
+    error?: string;
+    /** Arbitrary result data returned by the handler. */
+    result?: unknown;
+    /** Captured log lines. */
+    logs: string[];
+    /** Whether this was a manual trigger. */
+    manual?: boolean;
+}

package/dist/types/src/types/data_source.d.ts

@@ -38,7 +38,7 @@ export interface DataSourceCapabilities {
  * Useful when you only need to check capabilities without UI metadata.
  * @group Models
  */
-export type DataSourceFeatures = Pick<DataSourceCapabilities, "supportsRelations" | "supportsSubcollections" | "supportsRLS" | "supportsReferences" | "supportsColumnTypes" | "supportsRealtime" | "supportsSQLAdmin" | "supportsDocumentAdmin" | "supportsSchemaAdmin">;
+export type DataSourceFeatures = Omit<DataSourceCapabilities, "key" | "label">;
 /** @group Models */
 export declare const POSTGRES_CAPABILITIES: DataSourceCapabilities;
 /** @group Models */

package/dist/types/src/types/entity_actions.d.ts

@@ -1,10 +1,10 @@
 import React from "react";
-import { Entity } from "./entities";
-import { EntityCollection, SelectionController } from "./collections";
-import { FormContext } from "./entity_views";
-import { User } from "../users";
-import { RebaseContext } from "../rebase_context";
-import { SideEntityController } from "../controllers";
+import type { Entity } from "./entities";
+import type { EntityCollection, 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";
 /**
  * An entity action is a custom action that can be performed on an entity.
  * They are displayed in the entity view and in the collection view.
@@ -55,7 +55,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     entity?: Entity<M>;
     context: RebaseContext<USER>;
     path?: string;
-    collection?: EntityCollection<Record<string, unknown>, any>;
+    collection?: EntityCollection<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.
@@ -72,7 +72,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     /**
      * If the action is rendered in the form, is it open in a side panel or full screen?
      */
-    openEntityMode: "side_panel" | "full_screen";
+    openEntityMode: "side_panel" | "full_screen" | "split";
     /**
      * Optional selection controller, present if the action is being called from a collection view
      */

package/dist/types/src/types/entity_callbacks.d.ts

@@ -1,14 +1,14 @@
-import { EntityCollection } from "./collections";
-import { Entity, EntityStatus, EntityValues } from "./entities";
-import { User } from "../users";
-import { RebaseCallContext } from "../rebase_context";
+import type { EntityCollection } from "./collections";
+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.
  * @group Models
  */
-export type EntityCallbacks<M extends Record<string, any> = any, USER extends User = User> = {
+export type EntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = {
     /**
      * Callback used after fetching data
      * @param props
@@ -51,11 +51,11 @@ export type EntityCallbacks<M extends Record<string, any> = any, USER extends Us
  * Parameters passed to hooks when an entity is fetched
  * @group Models
  */
-export interface EntityAfterReadProps<M extends Record<string, any> = any, USER extends User = User> {
+export interface EntityAfterReadProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * Collection of the entity
      */
-    collection: EntityCollection<Record<string, unknown>, any>;
+    collection: EntityCollection<M>;
     /**
      * Full path of the CMS where this collection is being fetched.
      * Might contain unresolved aliases.
@@ -74,25 +74,25 @@ export interface EntityAfterReadProps<M extends Record<string, any> = any, USER
  * Parameters passed to hooks before an entity is saved
  * @group Models
  */
-export type EntityBeforeSaveProps<M extends Record<string, any> = any, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
+export type EntityBeforeSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
     entityId?: string | number;
 };
 /**
  * Parameters passed to hooks before an entity is saved
  * @group Models
  */
-export type EntityAfterSaveErrorProps<M extends Record<string, any> = any, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
+export type EntityAfterSaveErrorProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
     entityId?: string | number;
 };
 /**
  * Parameters passed to hooks when an entity is saved
  * @group Models
  */
-export interface EntityAfterSaveProps<M extends Record<string, any> = any, USER extends User = User> {
+export interface EntityAfterSaveProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * Resolved collection of the entity
      */
-    collection: EntityCollection<Record<string, unknown>, any>;
+    collection: EntityCollection<M>;
     /**
      * Full path of the CMS where this entity is being saved.
      * Might contain unresolved aliases.
@@ -123,11 +123,11 @@ export interface EntityAfterSaveProps<M extends Record<string, any> = any, USER
  * Parameters passed to hooks when an entity is deleted
  * @group Models
  */
-export interface EntityBeforeDeleteProps<M extends Record<string, any> = any, USER extends User = User> {
+export interface EntityBeforeDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * collection of the entity being deleted
      */
-    collection: EntityCollection<Record<string, unknown>, any>;
+    collection: EntityCollection<M>;
     /**
      * Path of the parent collection
      */
@@ -149,11 +149,11 @@ export interface EntityBeforeDeleteProps<M extends Record<string, any> = any, US
  * Parameters passed to hooks after an entity is deleted
  * @group Models
  */
-export interface EntityAfterDeleteProps<M extends Record<string, any> = any, USER extends User = User> {
+export interface EntityAfterDeleteProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
     /**
      * collection of the entity being deleted
      */
-    collection: EntityCollection<Record<string, unknown>, any>;
+    collection: EntityCollection<M>;
     /**
      * Path of the parent collection
      */

package/dist/types/src/types/entity_link_builder.d.ts

@@ -2,6 +2,6 @@ import { Entity } from "./entities";
 /**
  * @group Models
  */
-export type EntityLinkBuilder<M extends Record<string, any> = any> = ({ entity }: {
+export type EntityLinkBuilder<M extends Record<string, unknown> = Record<string, unknown>> = ({ entity }: {
     entity: Entity<M>;
 }) => string;

package/dist/types/src/types/entity_overrides.d.ts

@@ -1,4 +1,5 @@
-import { DataDriver, StorageSource } from "../controllers";
+import type { DataDriver } from "../controllers/data_driver";
+import type { StorageSource } from "../controllers/storage";
 export type EntityOverrides = {
     /**
      * Internal driver override for this collection.