@rebasepro/server-core 0.2.1 → 0.2.4

package/dist/server-core/src/auth/jwt.d.ts

@@ -7,6 +7,8 @@ export interface AccessTokenPayload {
     userId: string;
     roles: string[];
     uid?: string;
+    /** Authentication Assurance Level: aal1 = password/oauth, aal2 = MFA verified */
+    aal?: "aal1" | "aal2";
 }
 /**
  * Configure JWT settings - call this during initialization.
@@ -16,7 +18,7 @@ export declare function configureJwt(config: JwtConfig): void;
 /**
  * Generate an access token (short-lived, 1 hour by default)
  */
-export declare function generateAccessToken(userId: string, roles: string[]): string;
+export declare function generateAccessToken(userId: string, roles: string[], aal?: "aal1" | "aal2", customClaims?: Record<string, unknown>): string;
 /**
  * Get the expiration time of an access token in milliseconds from now
  */

package/dist/server-core/src/auth/mfa.d.ts

@@ -0,0 +1,49 @@
+/**
+ * TOTP (Time-based One-Time Password) implementation.
+ *
+ * Pure Node.js crypto implementation — no external dependencies required.
+ * Implements RFC 6238 (TOTP) and RFC 4226 (HOTP).
+ */
+/**
+ * Encode a Buffer to Base32 string (RFC 4648)
+ */
+export declare function base32Encode(buffer: Buffer): string;
+/**
+ * Decode a Base32 string to Buffer
+ */
+export declare function base32Decode(encoded: string): Buffer;
+/**
+ * Generate a TOTP value for the current time step
+ */
+export declare function generateTotp(secret: Buffer, timeStep?: number): string;
+/**
+ * Verify a TOTP token with a configurable time window
+ *
+ * @param secret - The shared secret as a Buffer
+ * @param token - The 6-digit TOTP code to verify
+ * @param window - Number of time steps to check on each side (default: 1)
+ * @returns true if the token is valid within the window
+ */
+export declare function verifyTotp(secret: Buffer, token: string, window?: number): boolean;
+/**
+ * Generate a new TOTP secret and return the setup information
+ *
+ * @param issuer - The issuer name (app name) for the QR code
+ * @param accountName - The account identifier (usually email)
+ * @returns Object with base32 secret and otpauth URI
+ */
+export declare function generateTotpSecret(issuer: string, accountName: string): {
+    secret: string;
+    uri: string;
+};
+/**
+ * Generate a set of one-time recovery codes
+ *
+ * @param count - Number of recovery codes to generate (default: 10)
+ * @returns Array of formatted recovery code strings (e.g. "A1B2C-D3E4F")
+ */
+export declare function generateRecoveryCodes(count?: number): string[];
+/**
+ * Hash a recovery code for storage
+ */
+export declare function hashRecoveryCode(code: string): string;

package/dist/server-core/src/auth/middleware.d.ts

@@ -2,6 +2,7 @@ import { MiddlewareHandler, Context } from "hono";
 import { DataDriver } from "@rebasepro/types";
 import { AccessTokenPayload } from "./jwt";
 import { HonoEnv } from "../api/types";
+import type { ApiKeyStore } from "./api-keys/api-key-store";
 /**
  * Result from a custom auth validator.
  * - `false`/`null`/`undefined` = not authenticated
@@ -45,6 +46,12 @@ export interface AuthMiddlewareOptions {
      * timing attacks. The key must be at least 32 characters.
      */
     serviceKey?: string;
+    /**
+     * API key store for authenticating `rk_` prefixed tokens.
+     * When set, tokens starting with `rk_` are validated against the
+     * database instead of being treated as JWTs.
+     */
+    apiKeyStore?: ApiKeyStore;
 }
 /**
  * Hono middleware that requires a valid JWT token

package/dist/server-core/src/auth/rate-limiter.d.ts

@@ -28,4 +28,23 @@ export declare const defaultAuthLimiter: MiddlewareHandler<HonoEnv>;
  * 50 requests per 15 minutes per IP.
  */
 export declare const strictAuthLimiter: MiddlewareHandler<HonoEnv>;
+/**
+ * Key generator for API-key-based rate limiting.
+ *
+ * Uses the API key ID (from `c.get("apiKey")`) as the rate limit key.
+ * Falls back to IP-based keying when the request is not authenticated
+ * via an API key.
+ */
+export declare function apiKeyKeyGenerator(c: Parameters<MiddlewareHandler<HonoEnv>>[0]): string;
+/**
+ * Create a rate limiter specifically for API key requests.
+ *
+ * When a request is authenticated via an API key that has a `rate_limit`
+ * configured, this limiter enforces per-key limits using the key's ID
+ * as the rate limit bucket.
+ *
+ * @param defaultLimit - Fallback limit when the key has no `rate_limit` set.
+ * @param windowMs     - Time window in milliseconds (default: 15 minutes).
+ */
+export declare function createApiKeyRateLimiter(defaultLimit?: number, windowMs?: number): MiddlewareHandler<HonoEnv>;
 export {};

package/dist/server-core/src/auth/routes.d.ts

@@ -1,6 +1,6 @@
 import { Hono } from "hono";
 import type { AuthRepository, OAuthProvider } from "./interfaces";
-import type { AuthOverrides } from "./auth-overrides";
+import type { AuthHooks } from "./auth-hooks";
 import { EmailService, EmailConfig } from "../email";
 import { HonoEnv } from "../api/types";
 /**
@@ -19,10 +19,10 @@ export interface AuthModuleConfig {
     /** When true, blocks all self-registration regardless of `allowRegistration`. */
     disableSelfRegistration?: boolean;
     /**
-     * Auth overrides for customizing password hashing, credential
+     * Auth hooks for customizing password hashing, credential
      * verification, lifecycle hooks, etc.
      */
-    overrides?: AuthOverrides;
+    authHooks?: AuthHooks;
     /**
      * Callback that checks if bootstrap has already been completed.
      * Used by GET /auth/config to report `needsSetup` status.

package/dist/server-core/src/env.d.ts

@@ -20,6 +20,8 @@ declare const rebaseEnvSchema: z.ZodObject<{
     DB_POOL_MAX: z.ZodEffects<z.ZodDefault<z.ZodString>, number, string | undefined>;
     DB_POOL_IDLE_TIMEOUT: z.ZodEffects<z.ZodDefault<z.ZodString>, number, string | undefined>;
     DB_POOL_CONNECT_TIMEOUT: z.ZodEffects<z.ZodDefault<z.ZodString>, number, string | undefined>;
+    DATABASE_DIRECT_URL: z.ZodOptional<z.ZodString>;
+    DATABASE_READ_URL: z.ZodOptional<z.ZodString>;
     FORCE_LOCAL_STORAGE: z.ZodEffects<z.ZodOptional<z.ZodEnum<["true", "false", ""]>>, boolean, "" | "true" | "false" | undefined>;
     STORAGE_TYPE: z.ZodDefault<z.ZodEnum<["local", "s3"]>>;
     STORAGE_PATH: z.ZodOptional<z.ZodString>;
@@ -50,6 +52,8 @@ declare const rebaseEnvSchema: z.ZodObject<{
     REBASE_SERVICE_KEY?: string | undefined;
     CORS_ORIGINS?: string | undefined;
     FRONTEND_URL?: string | undefined;
+    DATABASE_DIRECT_URL?: string | undefined;
+    DATABASE_READ_URL?: string | undefined;
     STORAGE_PATH?: string | undefined;
     S3_BUCKET?: string | undefined;
     S3_REGION?: string | undefined;
@@ -74,6 +78,8 @@ declare const rebaseEnvSchema: z.ZodObject<{
     DB_POOL_MAX?: string | undefined;
     DB_POOL_IDLE_TIMEOUT?: string | undefined;
     DB_POOL_CONNECT_TIMEOUT?: string | undefined;
+    DATABASE_DIRECT_URL?: string | undefined;
+    DATABASE_READ_URL?: string | undefined;
     FORCE_LOCAL_STORAGE?: "" | "true" | "false" | undefined;
     STORAGE_TYPE?: "local" | "s3" | undefined;
     STORAGE_PATH?: string | undefined;

package/dist/server-core/src/index.d.ts

@@ -29,3 +29,4 @@ export * from "./serve-spa";
 export * from "./utils/dev-port";
 export { loadEnv } from "./env";
 export type { RebaseEnv } from "./env";
+export { z } from "zod";

package/dist/server-core/src/init.d.ts

@@ -7,7 +7,7 @@ import { HonoEnv } from "./api/types";
 import { BackendStorageConfig, StorageController, StorageRegistry } from "./storage";
 import { EmailConfig } from "./email";
 import type { OAuthProvider } from "./auth/interfaces";
-import type { AuthOverrides } from "./auth/auth-overrides";
+import type { AuthHooks } from "./auth/auth-hooks";
 export interface RebaseAuthConfig {
     jwtSecret?: string;
     accessExpiresIn?: string;
@@ -93,13 +93,13 @@ export interface RebaseAuthConfig {
      * ```ts
      * import bcrypt from "bcrypt";
      *
-     * overrides: {
+     * hooks: {
      *     hashPassword: (pw) => bcrypt.hash(pw, 12),
      *     verifyPassword: (pw, hash) => bcrypt.compare(pw, hash),
      * }
      * ```
      */
-    overrides?: AuthOverrides;
+    hooks?: AuthHooks;
     [key: string]: unknown;
 }
 export interface RebaseBackendConfig {

package/dist/server-core/src/services/webhook-service.d.ts

@@ -0,0 +1,29 @@
+export interface WebhookConfig {
+    id: string;
+    url: string;
+    secret?: string;
+    headers?: Record<string, string>;
+    events: string[];
+    table: string;
+    enabled: boolean;
+}
+export interface WebhookDeliveryResult {
+    webhookId: string;
+    event: string;
+    payload: Record<string, unknown>;
+    statusCode: number;
+    responseBody: string;
+    success: boolean;
+    attemptNumber: number;
+}
+export declare class WebhookDispatcher {
+    private webhooks;
+    private maxRetries;
+    private retryDelays;
+    /** Register webhooks to watch */
+    setWebhooks(webhooks: WebhookConfig[]): void;
+    /** Called when an entity changes — checks if any webhook matches */
+    onEntityChange(table: string, event: "INSERT" | "UPDATE" | "DELETE", entityId: string, entity: Record<string, unknown> | null, previousEntity?: Record<string, unknown> | null): Promise<WebhookDeliveryResult[]>;
+    private deliverWithRetry;
+    private deliver;
+}

package/dist/server-core/src/storage/image-transform.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Image Transformation Service
+ *
+ * Provides on-the-fly image resize, crop, format conversion, and quality
+ * adjustment using the `sharp` library. Results are cached in an LRU
+ * in-memory cache to avoid redundant processing.
+ */
+/** Options that can be specified via query parameters. */
+export interface ImageTransformOptions {
+    width?: number;
+    height?: number;
+    quality?: number;
+    format?: "webp" | "avif" | "jpeg" | "png";
+    fit?: "cover" | "contain" | "fill" | "inside" | "outside";
+}
+/**
+ * Parse transform options from URL query parameters.
+ * Returns `null` when no transformation is requested.
+ */
+export declare function parseTransformOptions(query: Record<string, string>): ImageTransformOptions | null;
+/** Check whether a content type is a transformable image. */
+export declare function isTransformableImage(contentType: string): boolean;
+/**
+ * Apply image transformations and return the result buffer + content type.
+ */
+export declare function transformImage(buffer: Buffer | Uint8Array, options: ImageTransformOptions): Promise<{
+    data: Buffer;
+    contentType: string;
+}>;
+/**
+ * Simple LRU cache for transformed images.
+ *
+ * Entries expire after `maxAgeMs` (default: 1 hour) and the cache
+ * evicts the oldest entry when `maxEntries` is exceeded.
+ */
+export declare class TransformCache {
+    private cache;
+    private readonly maxEntries;
+    private readonly maxAgeMs;
+    constructor(maxEntries?: number, maxAgeMs?: number);
+    /** Build a deterministic cache key from file key + transform options. */
+    buildKey(fileKey: string, options: ImageTransformOptions): string;
+    get(cacheKey: string): {
+        data: Buffer;
+        contentType: string;
+    } | null;
+    set(cacheKey: string, data: Buffer, contentType: string): void;
+}

package/dist/server-core/src/storage/index.d.ts

@@ -15,6 +15,9 @@ export { S3StorageController } from "./S3StorageController";
 export { createStorageRoutes } from "./routes";
 export type { StorageRoutesConfig } from "./routes";
 export * from "./storage-registry";
+export { parseTransformOptions, transformImage, isTransformableImage, TransformCache } from "./image-transform";
+export type { ImageTransformOptions } from "./image-transform";
+export { TusHandler } from "./tus-handler";
 import { BackendStorageConfig, StorageController } from "./types";
 /**
  * Create a storage controller from a config object.

package/dist/server-core/src/storage/tus-handler.d.ts

@@ -0,0 +1,51 @@
+/**
+ * TUS Protocol Handler
+ *
+ * Implements the TUS v1.0.0 resumable upload protocol with the
+ * Creation and Termination extensions. Uploads are stored in a
+ * temporary directory and moved to final storage on completion.
+ *
+ * @see https://tus.io/protocols/resumable-upload
+ */
+import type { Context } from "hono";
+import type { StorageController } from "./types";
+/**
+ * TUS resumable upload handler.
+ *
+ * Each instance manages uploads for a single storage root. The
+ * `storageController` is used to finalize completed uploads by
+ * calling `putObject`.
+ */
+export declare class TusHandler {
+    private storageController?;
+    private uploads;
+    private tusDir;
+    private cleanupTimer?;
+    constructor(storageBaseDir: string, storageController?: StorageController | undefined);
+    /** Ensure the temp directory exists. */
+    private ensureDir;
+    /** Start periodic cleanup of stale uploads. */
+    startCleanup(): void;
+    /** Remove uploads that have been idle for longer than UPLOAD_EXPIRY_MS. */
+    private cleanupStale;
+    /**
+     * Parse the `Upload-Metadata` header.
+     *
+     * Format: `key base64value,key2 base64value2`
+     */
+    private parseMetadata;
+    /** `OPTIONS /tus` — TUS capability discovery. */
+    options(): Response;
+    /** `POST /tus` — Create a new upload. */
+    create(c: Context): Promise<Response>;
+    /** `HEAD /tus/:id` — Query upload progress. */
+    head(c: Context, id: string): Response;
+    /** `PATCH /tus/:id` — Append data to an upload. */
+    patch(c: Context, id: string): Promise<Response>;
+    /** `DELETE /tus/:id` — Cancel and remove an upload. */
+    delete(c: Context, id: string): Promise<Response>;
+    /**
+     * Move a completed upload into the storage controller.
+     */
+    private finalize;
+}

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

@@ -1,6 +1,4 @@
-import { StorageSource } from "./storage";
 import { Role, User } from "../users";
-import { RebaseData } from "./data";
 /**
  * Capabilities advertised by an auth provider.
  * UI components use this to show/hide features dynamically
@@ -89,6 +87,8 @@ export interface AuthControllerExtended<USER extends User = User, ExtraData = un
         code: string;
         redirectUri: string;
     }) => Promise<void>;
+    /** Generic OAuth login — works with any provider. Posts payload to /auth/{providerId}. */
+    oauthLogin?: (providerId: string, payload: Record<string, unknown>) => Promise<void>;
     /** Register a new user */
     register?(email: string, password: string, displayName?: string): Promise<void>;
     /** Skip login (for anonymous access if enabled) */
@@ -102,25 +102,3 @@ export interface AuthControllerExtended<USER extends User = User, ExtraData = un
     /** Update user profile */
     updateProfile?(displayName?: string, photoURL?: string): Promise<USER>;
 }
-/**
- * Implement this function to allow access to specific users.
- * @group Hooks and utilities
- */
-export type Authenticator<USER extends User = User> = (props: {
-    /**
-     * Logged-in user or null
-     */
-    user: USER | null;
-    /**
-     * AuthController
-     */
-    authController: AuthController<USER>;
-    /**
-     * Unified data access API
-     */
-    data: RebaseData;
-    /**
-     * Used storage implementation
-     */
-    storageSource: StorageSource;
-}) => boolean | Promise<boolean>;

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

@@ -65,7 +65,6 @@ export interface AdminRole {
     name: string;
     isAdmin: boolean;
     defaultPermissions: Record<string, unknown> | null;
-    config: Record<string, unknown> | null;
 }
 /**
  * Client-side Admin API interface.
@@ -123,7 +122,6 @@ export interface AdminAPI {
         name: string;
         isAdmin?: boolean;
         defaultPermissions?: Record<string, unknown>;
-        config?: Record<string, unknown>;
     }): Promise<{
         role: AdminRole;
     }>;
@@ -131,7 +129,6 @@ export interface AdminAPI {
         name?: string;
         isAdmin?: boolean;
         defaultPermissions?: Record<string, unknown>;
-        config?: Record<string, unknown>;
     }): Promise<{
         role: AdminRole;
     }>;

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

@@ -4,7 +4,7 @@ import type { EntityReference } from "../types/entities";
  * Controller that provides access to the registered entity collections.
  * @group Models
  */
-export type CollectionRegistryController<DB = Record<string, unknown>, EC extends EntityCollection = EntityCollection<any>> = {
+export type CollectionRegistryController<DB = Record<string, unknown>, EC extends EntityCollection = EntityCollection> = {
     /**
      * List of the mapped collections in the CMS.
      * Each entry relates to a collection in the root database.

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

@@ -76,6 +76,21 @@ export interface FindResponse<M extends Record<string, unknown> = Record<string,
         hasMore: boolean;
     };
 }
+export type FilterOperator = WhereFilterOpShort;
+/**
+ * Fluent Query Builder Interface supported on both client and server accessors.
+ * @group Data
+ */
+export interface QueryBuilderInterface<M extends Record<string, unknown> = Record<string, unknown>> {
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    search(searchString: string): this;
+    include(...relations: string[]): this;
+    find(): Promise<FindResponse<M>>;
+    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
+}
 /**
  * A single collection's CRUD accessor.
  *
@@ -124,6 +139,12 @@ export interface CollectionAccessor<M extends Record<string, unknown> = Record<s
      * Count the number of records matching the given filter.
      */
     count?(params?: FindParams): Promise<number>;
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): QueryBuilderInterface<M>;
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilderInterface<M>;
+    limit(count: number): QueryBuilderInterface<M>;
+    offset(count: number): QueryBuilderInterface<M>;
+    search(searchString: string): QueryBuilderInterface<M>;
+    include(...relations: string[]): QueryBuilderInterface<M>;
 }
 /**
  * The unified data access object.

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

@@ -17,6 +17,21 @@ export type ListenEntityProps<M extends Record<string, unknown> = Record<string,
     onUpdate: (entity: Entity<M> | null) => void;
     onError?: (error: Error) => void;
 };
+/**
+ * Configuration for vector similarity search queries.
+ * Vector search applies an ORDER BY distance expression and optionally
+ * filters results by a distance threshold.
+ */
+export interface VectorSearchParams {
+    /** Property name containing the vector column */
+    property: string;
+    /** Query vector to compare against */
+    vector: number[];
+    /** Distance function (default: "cosine") */
+    distance?: "cosine" | "l2" | "inner_product";
+    /** Only return results within this distance threshold */
+    threshold?: number;
+}
 /**
  * @internal
  */
@@ -30,6 +45,8 @@ export interface FetchCollectionProps<M extends Record<string, unknown> = Record
     orderBy?: string;
     searchString?: string;
     order?: "desc" | "asc";
+    /** Vector similarity search configuration */
+    vectorSearch?: VectorSearchParams;
 }
 /**
  * @internal
@@ -187,6 +204,7 @@ export interface RestFetchService {
         startAfter?: Record<string, unknown>;
         searchString?: string;
         databaseId?: string;
+        vectorSearch?: VectorSearchParams;
     }, include?: string[]): Promise<Record<string, unknown>[]>;
     /**
      * Fetch a single flattened entity with optional relation includes.

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

@@ -4,6 +4,7 @@ import type { EntityCollectionsBuilder } from "../types/builders";
 import type { EntityCustomView } from "../types/entity_views";
 import type { EntityAction } from "../types/entity_actions";
 import type { AppView, NavigationGroupMapping } from "./navigation";
+import type { RebasePlugin } from "../types/plugins";
 /**
  * Options to enable the built-in collection editor.
  * When provided to `<RebaseCMS>`, the editor is auto-wired as a native feature.
@@ -19,12 +20,12 @@ export interface CollectionEditorOptions {
     /** Suggested base paths shown when creating new collections. */
     pathSuggestions?: string[];
 }
-export interface RebaseCMSConfig<EC extends EntityCollection = any> {
+export interface RebaseCMSConfig<EC extends EntityCollection = EntityCollection> {
     collections?: EC[] | EntityCollectionsBuilder<EC>;
     homePage?: ReactNode;
-    entityViews?: EntityCustomView<any>[];
+    entityViews?: EntityCustomView[];
     entityActions?: EntityAction[];
-    plugins?: any[];
+    plugins?: RebasePlugin[];
     /**
      * Centralized configuration for how collections and views are grouped
      * in the navigation sidebar and home page.
@@ -42,7 +43,7 @@ export interface RebaseCMSConfig<EC extends EntityCollection = any> {
     collectionEditor?: boolean | CollectionEditorOptions;
 }
 export interface RebaseStudioConfig {
-    tools?: ("sql" | "js" | "rls" | "schema" | "storage" | "cron" | "schema-visualizer" | "branches" | "api")[];
+    tools?: ("sql" | "js" | "rls" | "schema" | "storage" | "cron" | "schema-visualizer" | "branches" | "api" | "logs")[];
     homePage?: ReactNode;
     devViews?: AppView[];
 }

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

@@ -28,7 +28,7 @@ export type RebaseCallContext<USER extends User = User> = {
      * const { client } = props.context;
      * const result = await client.functions.invoke('extract-job', { url });
      */
-    client: RebaseClient<any>;
+    client: RebaseClient;
     /**
      * Unified data access — `context.data.products.create(...)`.
      * Access any collection as a dynamic property.

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

@@ -133,7 +133,7 @@ export interface AuthUserData {
     displayName?: string | null;
     photoUrl?: string | null;
     emailVerified?: boolean;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     createdAt?: Date;
     updatedAt?: Date;
 }
@@ -146,7 +146,7 @@ export interface AuthCreateUserData {
     password?: string;
     displayName?: string;
     photoUrl?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Role data exposed by the auth adapter.
@@ -168,7 +168,6 @@ export interface AuthRoleData {
         edit?: boolean;
         delete?: boolean;
     }> | null;
-    config?: Record<string, unknown> | null;
 }
 /**
  * Data for creating a role.
@@ -180,7 +179,6 @@ export interface AuthCreateRoleData {
     isAdmin?: boolean;
     defaultPermissions?: AuthRoleData["defaultPermissions"];
     collectionPermissions?: AuthRoleData["collectionPermissions"];
-    config?: AuthRoleData["config"];
 }
 /**
  * User management operations for the admin panel.

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

@@ -589,10 +589,6 @@ export interface FilterPreset<Key extends string = string> {
      */
     sort?: [Key, "asc" | "desc"];
 }
-/**
- * @deprecated Use {@link FilterPreset} instead.
- */
-export type QuickFilter<Key extends string = string> = FilterPreset<Key>;
 /**
  * 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

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

@@ -37,7 +37,7 @@ export interface LazyComponentRef<P = unknown> {
  *
  * @group Types
  */
-export type ComponentRef<P = unknown> = React.ComponentType<P> | LazyComponentRef<P> | (() => Promise<{
+export type ComponentRef<P = any> = React.ComponentType<P> | LazyComponentRef<P> | (() => Promise<{
     default: React.ComponentType<P>;
 }>) | string;
 /**

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

@@ -44,7 +44,7 @@ export interface CronJobContext {
     /** A simple logger scoped to this job run. */
     log: (...args: unknown[]) => void;
     /** The RebaseClient instance to interact with the database. */
-    client: RebaseClient<any>;
+    client: RebaseClient;
 }
 export type CronJobRunState = "idle" | "running" | "success" | "error" | "disabled";
 /**

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

@@ -50,6 +50,7 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
 export type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = {
     key: string;
     name: string;
+    icon?: string | React.ReactNode;
     tabComponent?: React.ReactNode;
     includeActions?: boolean | "bottom";
     Builder?: ComponentRef<EntityCustomViewParams<M>>;

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

@@ -15,7 +15,7 @@ export interface ExportConfig<USER extends User = User> {
 export interface ExportMappingFunction<USER extends User = User> {
     key: string;
     builder: ({ entity, context }: {
-        entity: Entity<any>;
+        entity: Entity;
         context: RebaseContext<USER>;
     }) => Promise<string> | string;
 }

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

@@ -1,5 +1,5 @@
 import React, { FormEvent } from "react";
-export type FormexController<T = any> = {
+export type FormexController<T = unknown> = {
     values: T;
     initialValues: T;
     setValues: (values: T) => void;
@@ -32,7 +32,7 @@ export type FormexController<T = any> = {
     canUndo: boolean;
     canRedo: boolean;
 };
-export type FormexResetProps<T = any> = {
+export type FormexResetProps<T = unknown> = {
     values?: T;
     submitCount?: number;
     errors?: Record<string, string>;

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

@@ -104,8 +104,8 @@ export interface BaseUIConfig<CustomProps = unknown> {
     disabled?: boolean | PropertyDisabledConfig;
     widthPercentage?: number;
     customProps?: CustomProps;
-    Field?: ComponentRef<any>;
-    Preview?: ComponentRef<any>;
+    Field?: ComponentRef;
+    Preview?: ComponentRef;
 }
 export interface BaseProperty<CustomProps = unknown> {
     ui?: BaseUIConfig<CustomProps>;