weifuwu 0.30.0 → 0.30.2

package/dist/queue/index.d.ts

@@ -1,2 +1,12 @@
+/**
+ * Redis-backed job queue with cron scheduling.
+ *
+ * Usage:
+ *   const q = queue({ url: process.env.REDIS_URL })
+ *   q.process('email', async (job) => { await send(job.data) })
+ *   await q.add('email', { to: '...' })
+ *   q.cron('cleanup', '0 3 * * *', async () => { ... })
+ *   await q.run()
+ */
 import type { Queue, QueueOptions } from './types.ts';
 export declare function queue(opts?: QueueOptions): Queue;

package/dist/queue/types.d.ts

@@ -13,16 +13,14 @@ export interface QueueJob<T = unknown> {
     schedule?: string;
 }
 export interface QueueOptions {
-    /** Backend store. Default: 'memory'. */
-    store?: 'memory' | 'pg' | 'redis';
+    /** Redis client instance (auto-created if not provided). */
     redis?: Redis;
+    /** Redis URL (default: REDIS_URL env or redis://localhost:6379). */
     url?: string;
+    /** Key prefix (default: 'queue'). */
     prefix?: string;
+    /** Poll interval in ms (default: 200). */
     pollInterval?: number;
-    /** PostgreSQL client (required when store: 'pg'). */
-    pg?: {
-        sql: import('../types.ts').SqlClient;
-    };
 }
 export interface QueueInjected {
     queue: Queue;
@@ -32,7 +30,7 @@ export interface QueueJobWithError<T = unknown> extends QueueJob<T> {
     failedAt: number;
 }
 export interface Queue extends Middleware<Context, Context & QueueInjected>, Closeable {
-    /** Register a cron job. Uses queue's backend (memory/pg/redis) for execution. */
+    /** Register a cron job. */
     cron(pattern: string, handler: () => void | Promise<void>): {
         stop: () => void;
     };
@@ -55,7 +53,5 @@ export interface Queue extends Middleware<Context, Context & QueueInjected>, Clo
     retryFailed(jobId: string): Promise<boolean>;
     retryAllFailed(type?: string): Promise<number>;
     dashboard(): import('../core/router.ts').Router;
-    /** Create the jobs table (PG mode only; safe to call multiple times). */
-    migrate?(): Promise<void>;
     close(): Promise<void>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "weifuwu",
   "type": "module",
-  "version": "0.30.0",
+  "version": "0.30.2",
   "description": "Web-standard HTTP microframework for Node.js — (req, ctx) => Response",
   "exports": {
     ".": {
@@ -17,8 +17,8 @@
     "build": "node scripts/build.mjs",
     "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
     "typecheck": "tsc --noEmit",
-    "test": "node --test 'src/test/**/*.test.ts'",
-    "test:coverage": "node --experimental-test-coverage --test 'src/test/**/*.test.ts'",
+    "pretest": "docker compose up -d --wait 2>/dev/null; sleep 1",
+    "test": "node --env-file=.env --test 'src/test/**/*.test.ts'",
     "release": "node scripts/release.mjs",
     "release:dry": "node scripts/release.mjs --dry-run"
   },
@@ -27,8 +27,7 @@
     "graphql": "^16",
     "ioredis": "^5.11.0",
     "postgres": "^3.4.9",
-    "ws": "^8",
-    "zod": "^4.4.3"
+    "ws": "^8"
   },
   "devDependencies": {
     "@types/node": "^25",

package/dist/ai/provider.d.ts

@@ -1,45 +0,0 @@
-import type { Context, Middleware } from '../types.ts';
-import { generateText as aiGenerateText, streamText as aiStreamText, type LanguageModel, type EmbeddingModel } from 'ai';
-declare module '../types.ts' {
-    interface Context {
-        ai: AIProvider;
-    }
-}
-export interface AIProviderInjected {
-    ai: AIProvider;
-}
-export interface AIProviderOptions {
-    /** API base URL (default: OPENAI_BASE_URL env or http://localhost:11434/v1). */
-    baseURL?: string;
-    /** API key (default: OPENAI_API_KEY env or 'ollama'). */
-    apiKey?: string;
-    /** Chat model name (default: OPENAI_MODEL env or 'qwen3:0.6b'). */
-    model?: string;
-    /** Embedding model name (default: OPENAI_EMBEDDING_MODEL env or 'qwen3-embedding:0.6b'). */
-    embeddingModel?: string;
-    /** Vector dimension (default: EMBEDDING_DIMENSION env or 1024). */
-    embeddingDimension?: number;
-}
-export interface AIProvider {
-    /** Get the language model. Caches by default; pass a name to override. */
-    model(name?: string): LanguageModel;
-    /** Get the embedding model. Caches by default; pass a name to override. */
-    embeddingModel(name?: string): EmbeddingModel;
-    /** Embed a single text string into a vector. */
-    embed(text: string): Promise<number[]>;
-    /** Embed multiple text strings in batch. */
-    embedMany(texts: string[]): Promise<number[][]>;
-    /** The configured vector dimension. */
-    readonly dimension: number;
-    /**
-     * Generate text using the configured model.
-     * All options are passed through to the AI SDK's `generateText`, with `model` auto-injected.
-     */
-    generateText(params: Omit<Parameters<typeof aiGenerateText>[0], 'model'>): ReturnType<typeof aiGenerateText>;
-    /**
-     * Stream text using the configured model.
-     * All options are passed through to the AI SDK's `streamText`, with `model` auto-injected.
-     */
-    streamText(params: Omit<Parameters<typeof aiStreamText>[0], 'model'>): ReturnType<typeof aiStreamText>;
-}
-export declare function aiProvider(options?: AIProviderOptions): Middleware<Context, Context & AIProviderInjected> & AIProvider;

package/dist/ai/stream.d.ts

@@ -1,13 +0,0 @@
-import type { Context } from '../types.ts';
-import { Router } from '../core/router.ts';
-import type { AIProvider } from './provider.ts';
-export type AIHandler = (req: Request, ctx: Context) => Record<string, unknown> | Promise<Record<string, unknown>>;
-export declare const _ai: Record<string, any>;
-/**
- * Create a streaming AI endpoint.
- *
- * @param handler - Returns options for `streamText` or `streamObject` (if `schema` is present).
- * @param provider - Optional AI provider. If provided and the handler does not return a `model`,
- *                   `provider.model()` is used as the default.
- */
-export declare function aiStream(handler: AIHandler, provider?: AIProvider): Promise<Router>;

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli.js

@@ -1,178 +0,0 @@
-#!/usr/bin/env node
-
-// cli.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { execSync } from "node:child_process";
-import { join, dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var pkgRoot = existsSync(join(__dirname, "package.json")) ? __dirname : resolve(__dirname, "..");
-async function readPkg() {
-  return JSON.parse(
-    await import("node:fs/promises").then(
-      (fs) => fs.readFile(join(pkgRoot, "package.json"), "utf-8")
-    )
-  );
-}
-async function cmdVersion() {
-  const pkg = await readPkg();
-  console.log(pkg.version);
-}
-async function cmdInit(name, opts) {
-  const targetDir = resolve(process.cwd(), name);
-  if (existsSync(targetDir)) {
-    console.error(`Directory ${name} already exists.`);
-    process.exit(1);
-  }
-  const pkg = await readPkg();
-  const typesNodeVersion = pkg.devDependencies?.["@types/node"] || "^22";
-  if (opts.ssr) {
-    await generateReactSsr(targetDir, name, pkg.version, typesNodeVersion, opts.skipInstall);
-  } else {
-    await generateMinimal(targetDir, name, pkg.version, typesNodeVersion, opts.skipInstall);
-  }
-}
-async function generateMinimal(targetDir, name, version, typesNodeVersion, skipInstall) {
-  await mkdir(targetDir, { recursive: true });
-  await writeFile(
-    join(targetDir, "app.ts"),
-    [
-      `import { Router } from 'weifuwu'`,
-      ``,
-      `export const app = new Router()`,
-      ``,
-      `app.get('/', () => new Response('Hello from ${name}!'))`,
-      `app.get('/api/ping', () => Response.json({ pong: true, time: new Date().toISOString() }))`,
-      ``
-    ].join("\n")
-  );
-  await writeFile(
-    join(targetDir, "index.ts"),
-    [
-      `import { loadEnv, serve } from 'weifuwu'`,
-      `import { app } from './app.ts'`,
-      ``,
-      `loadEnv()`,
-      `const port = Number(process.env.PORT) || 3000`,
-      `serve(app.handler(), { port })`,
-      ``
-    ].join("\n")
-  );
-  await writePackageJson(targetDir, name, version, typesNodeVersion, {});
-  await writeCommonFiles(targetDir);
-  await finishInit(targetDir, skipInstall);
-}
-async function generateReactSsr(targetDir, name, version, typesNodeVersion, skipInstall) {
-  const templateDir = join(pkgRoot, "cli", "template", "react");
-  await copyRecursive(templateDir, targetDir);
-  await writePackageJson(targetDir, name, version, typesNodeVersion, {
-    dependencies: {
-      react: "^19",
-      "react-dom": "^19",
-      "@tailwindcss/postcss": "^4",
-      tailwindcss: "^4",
-      postcss: "^8"
-    },
-    devDependencies: {
-      "@types/react": "^19",
-      "@types/react-dom": "^19",
-      esbuild: "^0.28"
-    }
-  });
-  await writeFile(join(targetDir, ".gitignore"), "node_modules\n.env\n.weifuwu\n");
-  await finishInit(targetDir, skipInstall);
-}
-async function copyRecursive(src, dest) {
-  const { readdir, stat, copyFile } = await import("node:fs/promises");
-  const entries = await readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await mkdir(destPath, { recursive: true });
-      await copyRecursive(srcPath, destPath);
-    } else if (entry.isFile()) {
-      await copyFile(srcPath, destPath);
-    }
-  }
-}
-async function writePackageJson(targetDir, name, version, typesNodeVersion, extra) {
-  const pkg = {
-    name,
-    type: "module",
-    scripts: {
-      dev: "node --watch index.ts",
-      start: "node index.ts"
-    },
-    dependencies: {
-      weifuwu: "^" + version
-    },
-    devDependencies: {
-      "@types/node": typesNodeVersion
-    }
-  };
-  if (extra) {
-    if (extra.dependencies) {
-      Object.assign(pkg.dependencies, extra.dependencies);
-    }
-    if (extra.devDependencies) {
-      Object.assign(pkg.devDependencies, extra.devDependencies);
-    }
-  }
-  await writeFile(join(targetDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
-}
-async function writeCommonFiles(targetDir) {
-  await writeFile(join(targetDir, ".gitignore"), "node_modules\n.env\n.weifuwu\n");
-  await writeFile(join(targetDir, ".env"), "PORT=3000\n");
-}
-async function finishInit(targetDir, skipInstall) {
-  if (!skipInstall) {
-    console.log("\nInstalling dependencies...");
-    execSync("npm install", { cwd: targetDir, stdio: "inherit" });
-  }
-  console.log(`
-\u2705 Created ${targetDir.split("/").pop()}/`);
-  console.log(`   cd ${targetDir.split("/").pop()}`);
-  if (skipInstall) console.log(`   npm install`);
-  console.log(`   npm run dev`);
-}
-var cmd = process.argv[2];
-var HELP = `
-weifuwu \u2014 Web-standard HTTP microframework for Node.js
-
-Usage:
-  npx weifuwu init <name>                Create a new API project
-  npx weifuwu init <name> --ssr          Create a React SSR project
-  npx weifuwu init <name> --skip-install  Skip npm install
-  npx weifuwu version                    Print version
-`;
-if (cmd === "version" || cmd === "-v" || cmd === "--version") {
-  cmdVersion().catch(console.error);
-} else if (cmd === "init") {
-  const { values, positionals } = parseArgs({
-    args: process.argv.slice(3),
-    options: {
-      "skip-install": { type: "boolean" },
-      "ssr": { type: "boolean" },
-      "react": { type: "boolean" }
-    },
-    strict: false,
-    allowPositionals: true
-  });
-  const name = positionals[0];
-  if (!name) {
-    console.error("Usage: npx weifuwu init <name> [--ssr] [--skip-install]");
-    process.exit(1);
-  }
-  cmdInit(name, {
-    skipInstall: !!values["skip-install"],
-    ssr: !!(values["ssr"] || values["react"])
-  }).catch(
-    console.error
-  );
-} else {
-  console.log(HELP);
-}

package/dist/core/cookie.d.ts

@@ -1,36 +0,0 @@
-/** Options for setting a cookie. All fields map to standard Set-Cookie attributes. */
-export interface CookieOptions {
-    domain?: string;
-    path?: string;
-    maxAge?: number;
-    expires?: Date;
-    httpOnly?: boolean;
-    secure?: boolean;
-    sameSite?: 'strict' | 'lax' | 'none';
-}
-/** Parse cookies from a Request's `Cookie` header.
- *
- * @example
- * ```ts
- * const cookies = getCookies(req)
- * console.log(cookies.session_id) // value or undefined
- * ``` */
-export declare function getCookies(req: Request): Record<string, string>;
-/** Set a cookie on a Response.
- *
- * Appends a `Set-Cookie` header to the existing response headers.
- * Returns a new Response with the added header.
- *
- * @example
- * ```ts
- * const res = new Response('ok')
- * return setCookie(res, 'session', token, { httpOnly: true, path: '/' })
- * ``` */
-export declare function setCookie(res: Response, name: string, value: string, options?: CookieOptions): Response;
-/** Delete a cookie by setting `Max-Age=0`.
- *
- * @example
- * ```ts
- * return deleteCookie(res, 'session')
- * ``` */
-export declare function deleteCookie(res: Response, name: string, options?: Omit<CookieOptions, 'maxAge'>): Response;

package/dist/core/env.d.ts

@@ -1,69 +0,0 @@
-import type { Context, Middleware } from '../types.ts';
-/**
- * Get all public environment variables (those prefixed with `WEIFUWU_PUBLIC_`),
- * with the prefix stripped.
- *
- * ```ts
- * const pub = getPublicEnv()
- * // WEIFUWU_PUBLIC_API_URL=http://api.example.com → { API_URL: 'http://api.example.com' }
- * ```
- */
-export declare function getPublicEnv(): Record<string, string>;
-declare module '../types.ts' {
-    interface Context {
-        env?: Record<string, string>;
-    }
-}
-/**
- * Whether this code is running from the compiled `dist/index.js` bundle.
- * `false` when running TypeScript source directly (dev workflow in weifuwu repo).
- *
- * Used by modules that need to resolve package-internal files differently
- * depending on whether they are compiled (published npm package) or raw TS.
- */
-export declare function isBundled(): boolean;
-/**
- * Whether `NODE_ENV` is explicitly set to `'development'`.
- *
- * Used for dev-only features: HMR, livereload, React `createRoot` (not hydrate).
- * **Not** the opposite of {@link isProd} — when `NODE_ENV` is unset, both return `false`.
- */
-export declare function isDev(): boolean;
-/**
- * Whether `NODE_ENV` is explicitly set to `'production'`.
- *
- * Used for production-only behavior: plain-text 404, suppressed warnings, minified output.
- */
-export declare function isProd(): boolean;
-/**
- * Load environment variables from a `.env` file into `process.env`.
- *
- * Does **not** override existing `process.env` values.
- * Supports quoted values and inline comments.
- *
- * @param path - Path to `.env` file (default: `'.env'` relative to cwd).
- *
- * ```ts
- * import { loadEnv } from 'weifuwu'
- * loadEnv()
- * console.log(process.env.PORT)
- * ```
- */
-export declare function loadEnv(path?: string): void;
-/**
- * Public env middleware.
- *
- * Injects `ctx.env` with all environment variables prefixed with `WEIFUWU_PUBLIC_`,
- * with the prefix stripped. Safe to expose to the client.
- *
- * ```ts
- * import { env } from 'weifuwu'
- * app.use(env())
- *
- * // .env:  WEIFUWU_PUBLIC_API_URL=https://api.example.com
- * // ctx:   ctx.env.API_URL === 'https://api.example.com'
- * ```
- */
-export declare function env(): Middleware<Context, Context & {
-    env: Record<string, string>;
-}>;

package/dist/core/html.d.ts

@@ -1,34 +0,0 @@
-/**
- * Safe HTML rendering via tagged template literals.
- *
- * Auto-escapes interpolated values to prevent XSS.
- * Use `raw()` for trusted HTML that should not be escaped.
- *
- * ```ts
- * import { html, raw } from '@weifuwujs/core'
- *
- * html`<h1>${title}</h1>`               // auto-escaped
- * html`<div>${raw(trustedHtml)}</div>`   // unescaped
- * html`<ul>${items.map(i => html`<li>${i}</li>`)}</ul>`  // arrays
- * html`${isAdmin && html`<button>Admin</button>`}`        // conditionals
- * html`<div>${html`<span>nested</span>`}</div>`           // nested (safe)
- * ```
- */
-interface RawHtml {
-    _raw: string;
-}
-export type HtmlValue = string | number | boolean | null | undefined | HtmlValue[] | RawHtml;
-/**
- * Tagged template literal for safe HTML.
- *
- * Interpolated values are auto-escaped. Use {@link raw} to bypass escaping
- * for trusted HTML. Nested `html` calls are safe (not double-escaped).
- */
-export declare function html(strings: TemplateStringsArray, ...values: HtmlValue[]): string;
-/**
- * Bypass HTML escaping for trusted content.
- *
- * Can be used standalone or inside {@link html} tagged templates.
- */
-export declare function raw(content: string): HtmlValue;
-export {};

package/dist/core/sse.d.ts

@@ -1,47 +0,0 @@
-/**
- * Format an SSE message string with a named event type.
- *
- * ```ts
- * formatSSE('ping', { ts: Date.now() })
- * // "event: ping\ndata: {"ts":...}\n\n"
- * ```
- */
-export declare function formatSSE(event: string, data: unknown): string;
-/**
- * Format an SSE message string with only a data line (no event type).
- *
- * ```ts
- * formatSSEData({ message: 'hello' })
- * // "data: {"message":"hello"}\n\n"
- * ```
- */
-export declare function formatSSEData(data: unknown): string;
-/** An SSE event to be sent via {@link createSSEStream}. */
-export interface SSEEvent {
-    /** Event type (maps to `event:` field). */
-    event: string;
-    /** Event payload (serialized as JSON in `data:` field). */
-    data: unknown;
-}
-/**
- * Create a Server-Sent Events (SSE) `Response` from an async iterable.
- *
- * Each item in the iterable is serialized as an SSE message:
- * - If the item has a `.type` property → `event: {type}` + `data: {item}`
- * - Otherwise → `data: {item}`
- *
- * Errors are sent as `event: error` messages. `AbortError` is silently ignored.
- *
- * ```ts
- * app.get('/events', () => {
- *   async function* generate() {
- *     yield { type: 'ping', data: { ts: Date.now() } }
- *   }
- *   return createSSEStream(generate())
- * })
- * ```
- */
-export declare function createSSEStream(iterable: AsyncIterable<any>, opts?: {
-    headers?: Record<string, string>;
-    status?: number;
-}): Response;

package/dist/middleware/csrf.d.ts

@@ -1,31 +0,0 @@
-import type { Context, Middleware } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        csrf: CsrfInjected;
-    }
-}
-export interface CsrfInjected {
-    token: string;
-}
-/** CSRF protection module — a {@link Middleware} that injects `ctx.csrf`. */
-export type CsrfModule = Middleware<Context, Context & CsrfInjected>;
-export interface CsrfOptions {
-    /** Cookie name for CSRF token (default: `'_csrf'`). */
-    cookie?: string;
-    /** Request header name for CSRF token (default: `'x-csrf-token'`). */
-    header?: string;
-    /** Form body key for CSRF token (default: `'_csrf'`). */
-    key?: string;
-    /** HTTP methods to exclude from CSRF protection (default: `['GET', 'HEAD', 'OPTIONS']`). */
-    excludeMethods?: string[];
-}
-/**
- * CSRF protection middleware.
- *
- * On excluded methods (GET, HEAD, OPTIONS), generates a token and stores it
- * in a cookie. On other methods, validates the token from header or body
- * against the cookie.
- *
- * Injects `ctx.csrf.token` for use in forms.
- */
-export declare function csrf(options?: CsrfOptions): Middleware<Context, Context & CsrfInjected>;

package/dist/middleware/flash.d.ts

@@ -1,44 +0,0 @@
-import type { Context, Middleware } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        flash: FlashInjected;
-    }
-}
-/** Flash message module — a {@link Middleware} that injects `ctx.flash`. */
-export type FlashModule = Middleware<Context, Context & FlashInjected>;
-/** Options for {@link flash}. */
-export interface FlashOptions {
-    /**
-     * Cookie name to store the flash message.
-     * @default 'flash'
-     */
-    name?: string;
-}
-/**
- * Flash message object injected into `ctx.flash`.
- */
-export interface FlashInjected {
-    /**
-     * The flash value read from the incoming cookie.
-     * `undefined` if no flash cookie is present.
-     * Automatically cleared after the response is sent.
-     */
-    value: unknown;
-    /**
-     * Set a flash message and return a 302 redirect response.
-     *
-     * @param data - Any JSON-serializable value to store as the flash message.
-     * @param location - Redirect location (defaults to the `Referer` header).
-     * @returns A 302 Response with a `Set-Cookie` header.
-     */
-    set: (data: unknown, location?: string) => Response;
-}
-/**
- * Flash message middleware — injects `ctx.flash`.
- *
- * @param options - Cookie name configuration.
- * @returns Middleware that injects `ctx.flash` (`FlashInjected`).
- */
-export declare function flash(options?: FlashOptions): Middleware<Context, Context & {
-    flash: FlashInjected;
-}>;

package/dist/middleware/health.d.ts

@@ -1,24 +0,0 @@
-import { Router } from '../core/router.ts';
-/** Options for {@link health}. */
-export interface HealthOptions {
-    /** Health check endpoint path (default: `'/__health'`). */
-    path?: string;
-    /** Async function that throws if the service is unhealthy. Called on each request. */
-    check?: () => Promise<void>;
-}
-/**
- * Health check endpoint.
- *
- * Returns 200 with `'OK'` if the check passes, 503 if it fails.
- *
- * ```ts
- * import { health } from 'weifuwu'
- *
- * app.use(health({
- *   check: async () => {
- *     await db.query('SELECT 1')
- *   },
- * }))
- * ```
- */
-export declare function health(options?: HealthOptions): Router;

package/dist/middleware/i18n.d.ts

@@ -1,39 +0,0 @@
-import { Router } from '../core/router.ts';
-import type { Context, Middleware } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        i18n: I18nInjected;
-    }
-}
-export interface I18nInjected {
-    locale: string;
-    messages?: Record<string, unknown>;
-    t: (key: string, params?: Record<string, string>, fallback?: string) => string;
-    set?: (value: string, loc?: string) => Response;
-}
-export interface I18nOptions {
-    /** Default locale (default: 'en'). */
-    default?: string;
-    /** Directory containing `{locale}.json` translation files. */
-    dir?: string;
-    /** Inline translation messages keyed by locale. */
-    messages?: Record<string, Record<string, unknown>>;
-    /** Cookie name for locale (default: 'locale'). Set empty to disable. */
-    cookie?: string;
-    /** Whether to detect locale from Accept-Language header (default: true). */
-    fromAcceptLanguage?: boolean;
-}
-/**
- * i18n module. Returns a Router with an attached `.middleware()` method.
- *
- * ```ts
- * const l = i18n({ dir: './locales' })
- * app.use(l.middleware())  // → ctx.i18n = { locale, t, set }
- * app.mount('/', l)          // → GET /__lang/:locale (switch route)
- * ```
- */
-export interface I18nModule extends Router {
-    /** Middleware that injects `ctx.i18n = { locale, t, set }`. */
-    middleware: () => Middleware<Context, Context & I18nInjected>;
-}
-export declare function i18n(options?: I18nOptions): I18nModule;