@rebasepro/server-core 0.2.3 → 0.2.5

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";
+import type { User } from "../users";
 /**
  * Capabilities advertised by an auth provider.
  * UI components use this to show/hide features dynamically
@@ -64,7 +62,7 @@ export type AuthController<USER extends User = User, ExtraData = unknown> = {
     extra: ExtraData;
     setExtra: (extra: ExtraData) => void;
     setUser?(user: USER | null): void;
-    setUserRoles?(roles: Role[]): void;
+    setUserRoles?(roles: string[]): void;
     /**
      * Capabilities advertised by the auth provider.
      * UI components use this to feature-detect what the backend supports.
@@ -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

@@ -1,6 +1,6 @@
-import { User } from "../users";
-import { RebaseData } from "./data";
-import { EmailService } from "./email";
+import type { User } from "../users";
+import type { RebaseData } from "./data";
+import type { EmailService } from "./email";
 /**
  * Event type for authentication state changes
  */
@@ -14,7 +14,7 @@ export interface RebaseSession {
     expiresAt: number;
     user: User;
 }
-import { StorageSource } from "./storage";
+import type { StorageSource } from "./storage";
 /**
  * Unified Authentication Client Interface
  * Pure functional SDK interface, decoupled from UI and React hooks
@@ -56,20 +56,9 @@ export interface AdminUser {
     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.
+ * Provides user management operations.
  * @group Admin
  */
 export interface AdminAPI {
@@ -112,32 +101,6 @@ export interface AdminAPI {
     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;
@@ -168,7 +131,7 @@ export interface RebaseClient<DB = unknown> {
      * > The client-side SDK does not include an email service.
      */
     email?: EmailService;
-    /** Admin API for user and role management */
+    /** Admin API for user management */
     admin?: AdminAPI;
     /**
      * The base HTTP URL of the backend server.
@@ -183,4 +146,23 @@ export interface RebaseClient<DB = unknown> {
      * detection (e.g. `typeof ws.executeSql === "function"`).
      */
     ws?: unknown;
+    /**
+     * Execute raw SQL against the database.
+     *
+     * Only available server-side when the backend uses a SQL database
+     * (PostgreSQL, MySQL, etc.). `undefined` for document databases
+     * (MongoDB, Firestore) and on the client-side SDK.
+     *
+     * @example
+     * ```typescript
+     * // In a cron job or custom function:
+     * if (ctx.client.sql) {
+     *     const rows = await ctx.client.sql("SELECT count(*) FROM orders");
+     * }
+     * ```
+     */
+    sql?(query: string, options?: {
+        database?: string;
+        role?: string;
+    }): Promise<Record<string, unknown>[]>;
 }

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

@@ -125,6 +125,10 @@ export interface CollectionAccessor<M extends Record<string, unknown> = Record<s
      * Delete a record by ID.
      */
     delete(id: string | number): Promise<void>;
+    /**
+     * Delete all records in this collection.
+     */
+    deleteAll?(): Promise<void>;
     /**
      * Subscribe to a collection for real-time updates.
      * Optional method, may not be supported by all implementations (like stateless HTTP clients).

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
@@ -112,6 +129,11 @@ export interface DataDriver {
      * @return was the whole deletion flow successful
      */
     deleteEntity<M extends Record<string, unknown> = Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
+    /**
+     * Delete all entities from a collection.
+     * @param path Collection path
+     */
+    deleteAll?(path: string): Promise<void>;
     /**
      * Check if the given property is unique in the given collection
      * @param path Collection path
@@ -187,6 +209,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.