@rebasepro/server-core 0.7.0 → 0.9.0

package/dist/cron/define-cron.d.ts

@@ -0,0 +1,28 @@
+import type { CronJobDefinition } from "@rebasepro/types";
+/**
+ * Typed authoring helper for a cron job file. Identity at runtime —
+ * a plain default-exported {@link CronJobDefinition} works identically;
+ * this adds type inference and autocomplete.
+ *
+ * @see {@link defineFunction} for the equivalent custom-functions helper.
+ *
+ * @example
+ * ```ts
+ * import { defineCron } from "@rebasepro/server-core";
+ *
+ * export default defineCron({
+ *     name: "Nightly cleanup",
+ *     schedule: "0 3 * * *",
+ *     async handler({ client, log }) {
+ *         const { data: expired } = await client.data.sessions.find({
+ *             where: { expired: ["==", true] },
+ *         });
+ *         for (const session of expired) {
+ *             await client.data.sessions.delete(session.id);
+ *         }
+ *         log(`Deleted ${expired.length} expired sessions`);
+ *     },
+ * });
+ * ```
+ */
+export declare function defineCron(definition: CronJobDefinition): CronJobDefinition;

package/{src/cron/index.ts → dist/cron/index.d.ts}

@@ -1,5 +1,6 @@
 export { loadCronJobsFromDirectory } from "./cron-loader";
 export type { LoadedCronJob } from "./cron-loader";
+export { defineCron } from "./define-cron";
 export { CronScheduler, validateCronExpression } from "./cron-scheduler";
 export { createCronRoutes } from "./cron-routes";
 export { createCronStore } from "./cron-store";

package/dist/db/interfaces.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Database Abstraction Interfaces
+ *
+ * These interfaces define the contracts that any database backend must implement
+ * to be used with Rebase. This allows for pluggable database backends like
+ * PostgreSQL, MongoDB, MySQL, etc.
+ */
+import { DatabaseConnection, QueryFilter, FetchCollectionOptions, SearchOptions, CountOptions, ConditionBuilder, ConditionBuilderStatic, DataRepository, CollectionSubscriptionConfig, SingleSubscriptionConfig, RealtimeProvider, CollectionRegistryInterface, DataTransformer, BackendConfig, BackendInstance, BackendFactory } from "@rebasepro/types";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { PgTransaction } from "drizzle-orm/pg-core";
+/**
+ * Type representing either a direct database connection or a transaction.
+ * Used to allow services to operate within a transaction context.
+ * Note: `any` is intentional here — it represents a Drizzle client with
+ * a dynamic schema, enabling `db.query[tableName]` access without casts.
+ */
+export type DrizzleClient = NodePgDatabase<Record<string, unknown>> | PgTransaction<any, any, any>;
+export type { DatabaseConnection, QueryFilter, FetchCollectionOptions, SearchOptions, CountOptions, ConditionBuilder, ConditionBuilderStatic, DataRepository, CollectionSubscriptionConfig, SingleSubscriptionConfig, RealtimeProvider, CollectionRegistryInterface, DataTransformer, BackendConfig, BackendInstance, BackendFactory };

package/dist/dynamic-import-Dvh-K5fl.js

@@ -0,0 +1,22 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+//#region src/utils/dynamic-import.ts
+/**
+* Native ESM dynamic import.
+*
+* Wrapped in `new Function` so TypeScript / bundlers don't down-compile the
+* `import()` to `require()` — the loaders must import user-authored `.ts`/`.js`
+* files at runtime using the host's real ESM loader. This is the production
+* default for {@link loadFunctionsFromDirectory} / {@link loadCronJobsFromDirectory}.
+*
+* @internal
+*/
+var nativeDynamicImport = (() => {
+	const doImport = new Function("url", "return import(url)");
+	return (url) => doImport(url);
+})();
+//#endregion
+export { nativeDynamicImport as t };
+
+//# sourceMappingURL=dynamic-import-Dvh-K5fl.js.map

package/dist/dynamic-import-Dvh-K5fl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-import-Dvh-K5fl.js","names":[],"sources":["../src/utils/dynamic-import.ts"],"sourcesContent":["/**\n * Shape returned by a dynamic module import: an object whose `default`\n * property holds the module's default export (CJS `module.exports` is exposed\n * as `default` by Node's ESM interop).\n */\nexport interface ImportedModule {\n    default?: unknown;\n    [key: string]: unknown;\n}\n\n/**\n * Imports a module by file URL. Injected into the directory loaders so tests\n * can supply a deterministic importer.\n */\nexport type ModuleImporter = (url: string) => Promise<ImportedModule>;\n\n/**\n * Native ESM dynamic import.\n *\n * Wrapped in `new Function` so TypeScript / bundlers don't down-compile the\n * `import()` to `require()` — the loaders must import user-authored `.ts`/`.js`\n * files at runtime using the host's real ESM loader. This is the production\n * default for {@link loadFunctionsFromDirectory} / {@link loadCronJobsFromDirectory}.\n *\n * @internal\n */\nexport const nativeDynamicImport: ModuleImporter = (() => {\n    const doImport = new Function(\"url\", \"return import(url)\") as (url: string) => Promise<ImportedModule>;\n    return (url: string) => doImport(url);\n})();\n"],"mappings":";;;;;;;;;;;;;;AA0BA,IAAa,6BAA6C;CACtD,MAAM,WAAW,IAAI,SAAS,OAAO,oBAAoB;CACzD,QAAQ,QAAgB,SAAS,GAAG;AACxC,GAAG"}

package/dist/email/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Email module exports
+ */
+export type { EmailService, EmailSendOptions, SMTPConfig, EmailConfig, PasswordResetTemplateFunction, EmailVerificationTemplateFunction, UserInvitationTemplateFunction, WelcomeEmailTemplateFunction, MagicLinkTemplateFunction } from "./types";
+export { SMTPEmailService, createEmailService } from "./smtp-email-service";
+export { getPasswordResetTemplate, getEmailVerificationTemplate, getUserInvitationTemplate, getWelcomeEmailTemplate, getMagicLinkTemplate } from "./templates";

package/dist/email/smtp-email-service.d.ts

@@ -0,0 +1,30 @@
+import { EmailConfig, EmailSendOptions, EmailService } from "./types";
+/**
+ * SMTP Email Service implementation using Nodemailer
+ */
+export declare class SMTPEmailService implements EmailService {
+    private transporter;
+    private config;
+    private _initialized;
+    constructor(config: EmailConfig);
+    /**
+     * Lazily initialize the SMTP transporter on first use
+     */
+    private ensureTransporter;
+    /**
+     * Check if the email service is properly configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Send an email using SMTP or custom send function
+     */
+    send(options: EmailSendOptions): Promise<void>;
+    /**
+     * Verify SMTP connection (useful for startup checks)
+     */
+    verifyConnection(): Promise<boolean>;
+}
+/**
+ * Create an email service from configuration
+ */
+export declare function createEmailService(config: EmailConfig): EmailService;

package/dist/email/templates.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Default email templates for authentication emails
+ */
+interface TemplateUser {
+    email: string;
+    displayName?: string | null;
+}
+/**
+ * Default password reset email template
+ */
+export declare function getPasswordResetTemplate(resetUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default email verification template
+ */
+export declare function getEmailVerificationTemplate(verifyUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default user invitation email template
+ * Sent when an admin creates a new user account
+ */
+export declare function getUserInvitationTemplate(setPasswordUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default welcome email template
+ * Sent automatically when a new user registers
+ */
+export declare function getWelcomeEmailTemplate(user: TemplateUser, appName?: string, loginUrl?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default magic link email template
+ */
+export declare function getMagicLinkTemplate(magicLinkUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+export {};

package/{src/email/types.ts → dist/email/types.d.ts}

@@ -6,11 +6,8 @@
  * This file re-exports them for backward compatibility and adds server-specific
  * config types (SMTP, template functions, etc.).
  */
-
 import type { EmailService, EmailSendOptions } from "@rebasepro/types";
-
 export type { EmailService, EmailSendOptions };
-
 /**
  * SMTP server configuration
  */
@@ -24,47 +21,61 @@ export interface SMTPConfig {
     };
     name?: string;
 }
-
 /**
  * Template function for password reset emails
  */
-export type PasswordResetTemplateFunction = (
-    resetUrl: string,
-    user: { email: string; displayName?: string | null }
-) => { subject: string; html: string; text?: string };
-
+export type PasswordResetTemplateFunction = (resetUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
 /**
  * Template function for email verification emails
  */
-export type EmailVerificationTemplateFunction = (
-    verifyUrl: string,
-    user: { email: string; displayName?: string | null }
-) => { subject: string; html: string; text?: string };
-
+export type EmailVerificationTemplateFunction = (verifyUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
 /**
  * Template function for user invitation emails
  */
-export type UserInvitationTemplateFunction = (
-    setPasswordUrl: string,
-    user: { email: string; displayName?: string | null }
-) => { subject: string; html: string; text?: string };
-
+export type UserInvitationTemplateFunction = (setPasswordUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
 /**
  * Template function for welcome emails sent after registration
  */
-export type WelcomeEmailTemplateFunction = (
-    user: { email: string; displayName?: string | null },
-    appName: string
-) => { subject: string; html: string; text?: string };
-
+export type WelcomeEmailTemplateFunction = (user: {
+    email: string;
+    displayName?: string | null;
+}, appName: string) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
 /**
  * Template function for magic link emails
  */
-export type MagicLinkTemplateFunction = (
-    magicLinkUrl: string,
-    user: { email: string; displayName?: string | null }
-) => { subject: string; html: string; text?: string };
-
+export type MagicLinkTemplateFunction = (magicLinkUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
 /**
  * Complete email configuration
  */
@@ -73,42 +84,35 @@ export interface EmailConfig {
      * From address for all emails (e.g., "noreply@example.com" or "MyApp <noreply@example.com>")
      */
     from: string;
-
     /**
      * SMTP configuration for sending emails via SMTP server
      */
     smtp?: SMTPConfig;
-
     /**
      * Alternative: custom function to send emails
      * Use this for custom email providers (AWS SES SDK, Resend, etc.)
      */
     sendEmail?: (options: EmailSendOptions) => Promise<void>;
-
     /**
      * Base URL for password reset links (e.g., "https://myapp.com")
      * The reset link will be: {baseUrl}/reset-password?token={token}
      */
     resetPasswordUrl?: string;
-
     /**
      * Base URL for email verification links (e.g., "https://myapp.com")
      * The verification link will be: {baseUrl}/verify-email?token={token}
      */
     verifyEmailUrl?: string;
-
     /**
      * Base URL for magic link login (e.g., "https://myapp.com")
      * The magic link will be: {baseUrl}/auth/magic-link?token={token}
      * Falls back to `resetPasswordUrl` if not set.
      */
     magicLinkUrl?: string;
-
     /**
      * Application name to use in email templates
      */
     appName?: string;
-
     /**
      * Custom email templates (optional - defaults are provided)
      */

package/dist/env.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+/**
+ * The full set of environment variables recognized by a Rebase backend.
+ */
+declare const rebaseEnvSchema: z.ZodObject<{
+    NODE_ENV: z.ZodDefault<z.ZodEnum<{
+        production: "production";
+        development: "development";
+        test: "test";
+    }>>;
+    PORT: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DATABASE_URL: z.ZodString;
+    ADMIN_CONNECTION_STRING: z.ZodOptional<z.ZodString>;
+    JWT_SECRET: z.ZodString;
+    JWT_ACCESS_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    JWT_REFRESH_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    GOOGLE_CLIENT_ID: z.ZodOptional<z.ZodString>;
+    GOOGLE_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
+    REBASE_SERVICE_KEY: z.ZodOptional<z.ZodString>;
+    ALLOW_REGISTRATION: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false">>;
+    ALLOW_LOCALHOST_IN_PRODUCTION: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false" | undefined>>;
+    CORS_ORIGINS: z.ZodOptional<z.ZodString>;
+    FRONTEND_URL: z.ZodOptional<z.ZodString>;
+    DB_POOL_MAX: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DB_POOL_IDLE_TIMEOUT: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DB_POOL_CONNECT_TIMEOUT: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DATABASE_DIRECT_URL: z.ZodOptional<z.ZodString>;
+    DATABASE_READ_URL: z.ZodOptional<z.ZodString>;
+    FORCE_LOCAL_STORAGE: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false" | undefined>>;
+    STORAGE_TYPE: z.ZodDefault<z.ZodEnum<{
+        local: "local";
+        s3: "s3";
+    }>>;
+    STORAGE_PATH: z.ZodOptional<z.ZodString>;
+    S3_BUCKET: z.ZodOptional<z.ZodString>;
+    S3_REGION: z.ZodOptional<z.ZodString>;
+    S3_ACCESS_KEY_ID: z.ZodOptional<z.ZodString>;
+    S3_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
+    S3_ENDPOINT: z.ZodOptional<z.ZodString>;
+    S3_FORCE_PATH_STYLE: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false" | undefined>>;
+}, z.core.$strip>;
+/** Inferred type of the validated environment. */
+export type RebaseEnv = z.infer<typeof rebaseEnvSchema>;
+/**
+ * Load and validate the Rebase environment configuration from `process.env`.
+ *
+ * Call this **after** your `.env` file has been loaded (via `dotenv`, `--env-file`,
+ * container injection, etc.). This function does not load `.env` files itself —
+ * that is a deployment concern, not a framework concern.
+ *
+ * Behavior:
+ * - Auto-generates ephemeral `JWT_SECRET` and `REBASE_SERVICE_KEY` in
+ *   non-production mode so developers can start without manual setup.
+ * - Blocks auto-generated secrets in production.
+ * - Returns a fully typed, validated env object.
+ *
+ * Use `extend` to add your own typed env variables on top of the base Rebase schema:
+ *
+ * @example
+ * ```ts
+ * import dotenv from "dotenv";
+ * import { z } from "zod";
+ * import { loadEnv } from "@rebasepro/server-core";
+ *
+ * dotenv.config({ path: "../../.env" });
+ *
+ * // Basic — just Rebase env vars:
+ * export const env = loadEnv();
+ *
+ * // Extended — add your own typed vars:
+ * export const env = loadEnv({
+ *     extend: z.object({
+ *         SMTP_HOST: z.string().optional(),
+ *         SMTP_PORT: z.string().default("587").transform(Number),
+ *         STRIPE_SECRET_KEY: z.string(),
+ *     })
+ * });
+ * // env.SMTP_HOST  → string | undefined  (fully typed)
+ * // env.STRIPE_SECRET_KEY → string        (validated, required)
+ * ```
+ */
+export declare function loadEnv(): RebaseEnv;
+export declare function loadEnv<E extends z.ZodObject<z.ZodRawShape>>(options: {
+    extend: E;
+}): RebaseEnv & z.infer<E>;
+export {};

package/dist/functions/define-function.d.ts

@@ -0,0 +1,55 @@
+import { Hono } from "hono";
+import type { RebaseServerClient } from "@rebasepro/types";
+import type { HonoEnv } from "../api/types";
+/**
+ * Typed context injected into a function authored with {@link defineFunction}.
+ *
+ * Surfaces the app-scoped Rebase singleton so handlers don't need to reach
+ * for the global `rebase` import. Request-scoped values (the authenticated
+ * `user`, the RLS-scoped `driver`, the `apiKey`, the `requestId`) are typed
+ * on the Hono context via {@link HonoEnv} — read them with `c.get("user")`
+ * / `c.var.driver` inside a handler.
+ */
+export interface RebaseFunctionContext {
+    /**
+     * The server-side Rebase singleton (`dataAsAdmin`, `auth`, `storage`,
+     * `email`, `sql`).
+     *
+     * `rebase.dataAsAdmin` runs with **admin privileges and bypasses RLS** — use
+     * it only for trusted admin work. For user-scoped queries inside a handler,
+     * use the request `driver` (`c.var.driver`), which carries the caller's
+     * identity so RLS applies. (`rebase.data` is a deprecated alias for
+     * `rebase.dataAsAdmin`.)
+     */
+    rebase: RebaseServerClient;
+}
+/**
+ * Typed authoring contract for a custom backend function.
+ *
+ * A custom function is a file in the `functionsDir` that default-exports a
+ * Hono app; the loader mounts it at `/<filename>`. `defineFunction` is the
+ * typed opt-in for that contract: it hands you a pre-typed `Hono<HonoEnv>`
+ * app (so `c.var.user` / `c.var.driver` are typed) plus a
+ * {@link RebaseFunctionContext}, and returns exactly the Hono app the loader
+ * already accepts — so it is fully interchangeable with a plain
+ * `export default new Hono()`.
+ *
+ * @example
+ * ```ts
+ * import { defineFunction, requireAuth } from "@rebasepro/server-core";
+ *
+ * export default defineFunction((app, { rebase }) => {
+ *     app.use("/*", requireAuth);
+ *     app.get("/home", async (c) => {
+ *         const [stats] = await rebase.sql!(`SELECT count(*) AS n FROM orders`);
+ *         return c.json({ orders: Number(stats.n) });
+ *     });
+ * });
+ * ```
+ *
+ * @param definition Receives the function's Hono app and the typed context.
+ *   Register routes on the provided `app` and return nothing, or return your
+ *   own `Hono<HonoEnv>` app to use instead.
+ * @returns The Hono app to default-export from the function file.
+ */
+export declare function defineFunction(definition: (app: Hono<HonoEnv>, ctx: RebaseFunctionContext) => void | Hono<HonoEnv>): Hono<HonoEnv>;

package/dist/functions/function-loader.d.ts

@@ -0,0 +1,18 @@
+import { Hono } from "hono";
+import { type ModuleImporter } from "../utils/dynamic-import.js";
+export interface LoadedFunction {
+    /** Endpoint name derived from filename (e.g., "send-invoice") */
+    name: string;
+    /** The Hono sub-app to mount */
+    app: Hono<import("hono").Env>;
+}
+/**
+ * Auto-discover Hono route files from a directory.
+ *
+ * Each file should default-export a Hono app (or router).
+ * The filename (without extension) becomes the mount path:
+ *   `functions/send-invoice.ts` → mounted at `/send-invoice`
+ *
+ * This mirrors how `loadCollectionsFromDirectory` works for collections.
+ */
+export declare function loadFunctionsFromDirectory(directory: string, importModule?: ModuleImporter): Promise<LoadedFunction[]>;

package/dist/functions/function-routes.d.ts

@@ -0,0 +1,10 @@
+import { Hono } from "hono";
+import { HonoEnv } from "../api/types";
+import { LoadedFunction } from "./function-loader";
+/**
+ * Mount all loaded function routes under a single Hono router.
+ *
+ * Each function is mounted at `/<function-name>`, preserving
+ * whatever HTTP methods and middleware the Hono sub-app defines.
+ */
+export declare function createFunctionRoutes(functions: LoadedFunction[]): Hono<HonoEnv>;

package/{src/functions/index.ts → dist/functions/index.d.ts}

@@ -1,3 +1,5 @@
 export { loadFunctionsFromDirectory } from "./function-loader";
 export type { LoadedFunction } from "./function-loader";
 export { createFunctionRoutes } from "./function-routes";
+export { defineFunction } from "./define-function";
+export type { RebaseFunctionContext } from "./define-function";

package/dist/history/history-routes.d.ts

@@ -0,0 +1,23 @@
+import { Hono } from "hono";
+import { HonoEnv } from "../api/types";
+import { BackendCollectionRegistry } from "../collections/BackendCollectionRegistry";
+import { DataDriver } from "@rebasepro/types";
+/**
+ * Create Hono routes for entity history.
+ * Mounted at `{basePath}/data/:slug/:id/history`.
+ */
+export interface HistoryService {
+    fetchHistory(tableName: string, id: string, options: {
+        limit: number;
+        offset: number;
+    }): Promise<{
+        data: Record<string, unknown>[];
+        total: number;
+    }>;
+    fetchHistoryEntry(historyId: string): Promise<Record<string, unknown> | null>;
+}
+export declare function createHistoryRoutes(params: {
+    historyService: HistoryService;
+    registry: BackendCollectionRegistry;
+    driver: DataDriver;
+}): Hono<HonoEnv>;

package/{src/history/index.ts → dist/history/index.d.ts}

@@ -1,2 +1 @@
-
 export { createHistoryRoutes } from "./history-routes";

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @rebasepro/server-core
+ *
+ * Database-Agnostic Backend Core for Rebase.
+ * This package provides the core backend services, generic driver routing,
+ * and API layers. Database implementations (e.g., PostgreSQL) are provided
+ * by specialized driver packages like `@rebasepro/server-postgresql`.
+ */
+export { initializeRebaseBackend, isAuthAdapter, isDatabaseAdapter } from "./init";
+export type { RebaseBackendConfig, RebaseBackendInstance, RebaseAuthConfig } from "./init";
+export { rebase, _setRebaseMock, _resetRebaseMock } from "./singleton";
+export * from "./db/interfaces";
+export * from "./auth/interfaces";
+export { requireAuth, requireAdmin, optionalAuth, queryTokenAuth, fileTokenAuth, extractUserFromToken, hashPassword, verifyPassword, validatePasswordStrength, resolveAuthHooks, createBuiltinAuthAdapter, createCustomAuthAdapter, createGoogleProvider, createLinkedinProvider, createGitHubProvider, createMicrosoftProvider, createAppleProvider, createFacebookProvider, createTwitterProvider, createDiscordProvider, createGitLabProvider, createBitbucketProvider, createSlackProvider, createSpotifyProvider, isApiKeyToken, validateApiKey, httpMethodToOperation, isOperationAllowed } from "./auth";
+export type { AccessTokenPayload, PasswordValidationResult, AuthHooks, AuthMethod, ResolvedAuthHooks, BuiltinAuthAdapterConfig, GoogleProviderConfig, AuthMiddlewareOptions, AuthResult, ApiKey, ApiKeyMasked, ApiKeyPermission, ApiKeyWithSecret, CreateApiKeyRequest, UpdateApiKeyRequest, ApiKeyStore, ApiKeyOperation } from "./auth";
+export * from "./api/types";
+export * from "./api/errors";
+export * from "./email";
+export * from "./storage";
+export { createHistoryRoutes } from "./history";
+export { loadFunctionsFromDirectory, createFunctionRoutes, defineFunction } from "./functions";
+export type { LoadedFunction, RebaseFunctionContext } from "./functions";
+export { loadCronJobsFromDirectory, CronScheduler, validateCronExpression, createCronRoutes, createCronStore, defineCron } from "./cron";
+export type { LoadedCronJob, CronStore } from "./cron";
+export { authUid, authRoles, authJwt } from "./utils/sql";
+export { logger } from "./utils/logger";
+export type { Logger } from "./utils/logger";
+export { loadEnv } from "./env";
+export type { RebaseEnv } from "./env";
+export * from "./types";
+export * from "./services/driver-registry";
+export { cleanupDevPortFile, listenWithPortRetry } from "./utils/dev-port";
+export { serveSPA } from "./serve-spa";
+export { installShutdownHandlers } from "./init/shutdown";
+export type { ShutdownHandlerOptions } from "./init/shutdown";