tezx 3.0.14-beta → 3.0.14-beta2

package/middleware/bearer-auth.js

@@ -1,3 +1,4 @@
+import { TezXError, TezXErrorParse } from "../core/error.js";
 export const bearerAuth = (options) => {
     const { validate, realm = "API", onUnauthorized = (ctx, error) => {
         ctx.setStatus = 401;
@@ -7,23 +8,22 @@ export const bearerAuth = (options) => {
     return async (ctx, next) => {
         const auth = ctx.req.header("authorization");
         if (!auth || !auth.startsWith("Bearer ")) {
-            return onUnauthorized(ctx, new Error("Bearer token required"));
+            return onUnauthorized(ctx, new TezXError("Bearer token required"));
         }
         const token = auth.slice(7).trim();
         if (!token) {
-            return onUnauthorized(ctx, new Error("Empty token"));
+            return onUnauthorized(ctx, new TezXError("Empty token"));
         }
         try {
             const valid = await validate(token, ctx);
             if (!valid) {
-                return onUnauthorized(ctx, new Error("Invalid or expired token"));
+                return onUnauthorized(ctx, new TezXError("Invalid or expired token"));
             }
             ctx.token = token;
             await next();
         }
         catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            return onUnauthorized(ctx, error);
+            return onUnauthorized(ctx, TezXErrorParse(err));
         }
     };
 };

package/middleware/cache-control.d.ts

@@ -0,0 +1,30 @@
+import { Context } from "../core/context.js";
+import { TezXError } from "../core/error.js";
+import { HttpBaseResponse, Middleware } from "../types/index.js";
+export interface CacheRule {
+    /** 🎯 Condition to determine if this rule applies */
+    condition: (ctx: Context) => boolean;
+    /** ⏳ Max age (seconds) */
+    maxAge: number;
+    /** 🌐 Cache scope */
+    scope: "public" | "private";
+    /** 🏷️ Vary header list */
+    vary?: string[];
+}
+export interface CacheSettings extends Pick<CacheRule, "maxAge" | "scope" | "vary"> {
+}
+export interface CacheOptions {
+    /** 🧱 Default cache behavior */
+    defaultSettings: CacheSettings;
+    /** 🔧 Optional rules for dynamic caching */
+    rules?: readonly CacheRule[];
+    /** 📝 Logging hook */
+    /** 🚨 Error handler */
+    onError?: (error: TezXError, ctx: Context) => HttpBaseResponse;
+}
+/**
+ * ⚡ Ultra-lightweight, low-level cache control middleware.
+ * Adds 'Cache-Control', 'Expires', and optional 'Vary' headers.
+ */
+export declare const cacheControl: (opts: CacheOptions) => Middleware;
+export default cacheControl;

package/middleware/cache-control.js

@@ -0,0 +1,40 @@
+import { TezXErrorParse } from "../core/error.js";
+export const cacheControl = (opts) => {
+    const { defaultSettings, rules = [], onError = (err, ctx) => {
+        ctx.setStatus = 500;
+        ctx.body = { error: err.message ?? "Cache middleware failed" };
+    }, } = opts;
+    const len = rules.length | 0;
+    return async function cacheControlMiddleware(ctx, next) {
+        const method = ctx.method;
+        if (method !== "GET" && method !== "HEAD") {
+            return await next();
+        }
+        try {
+            await next();
+            let matched;
+            for (let i = 0; i < len; i++) {
+                const rule = rules[i];
+                if (rule.condition(ctx)) {
+                    matched = rule;
+                    break;
+                }
+            }
+            const settings = matched ?? defaultSettings;
+            const maxAge = settings.maxAge;
+            const scope = settings.scope;
+            const vary = settings.vary;
+            const cacheValue = `${scope}, max-age=${maxAge}`;
+            const expiresValue = new Date(Date.now() + maxAge * 1000).toUTCString();
+            const headers = ctx.headers;
+            headers.set("Cache-Control", cacheValue);
+            headers.set("Expires", expiresValue);
+            if (vary && vary.length > 0)
+                headers.set("Vary", vary.join(", "));
+        }
+        catch (err) {
+            return onError(TezXErrorParse(err), ctx);
+        }
+    };
+};
+export default cacheControl;

package/middleware/cors.js

@@ -1,5 +1,5 @@
 function cors(option = {}) {
-    const { credentials, maxAge, origin, } = option;
+    const { credentials, maxAge, origin } = option;
     let methods = (option.methods || ["GET", "POST", "PUT", "DELETE"]).join(", ");
     let allowedHeaders = (option.allowedHeaders || ["Content-Type", "Authorization"]).join(", ");
     let exposedHeaders = option?.exposedHeaders?.join(", ");

package/middleware/detect-bot.d.ts

@@ -0,0 +1,113 @@
+import { Context, Middleware } from "../index.js";
+import { HttpBaseResponse } from "../types/index.js";
+/**
+ * ⚙️ Configuration options for the `detectBot` middleware.
+ */
+export type DetectBotOptions = {
+    /**
+     * 🤖 List of known bot-like User-Agent patterns.
+     * @default ["bot", "spider", "crawl", "slurp"]
+     * @example
+     * botUserAgents: ["bot", "crawler", "indexer"]
+     */
+    botUserAgents?: string[];
+    /**
+     * ⚖️ Enable rate-limiting based bot detection.
+     * Requires `getConnInfo()` import from TezX runtime.
+     * @default false
+     * @example
+     * enableRateLimiting: true
+     */
+    enableRateLimiting?: boolean;
+    /**
+     * ⚠️ Maximum allowed requests in the rate-limit window.
+     * Only used when `enableRateLimiting` is true.
+     * @default 30
+     */
+    maxRequests?: number;
+    /**
+     * ⏱️ Time window for rate-limiting (in milliseconds).
+     * @default 60000 (1 minute)
+     */
+    windowMs?: number;
+    /**
+     * 🔄 Custom rate-limit storage implementation.
+     * Allows integration with Redis, Memcached, or in-memory stores.
+     * @default In-memory Map
+     * @example
+     * storage: {
+     *   get: (key) => myRedisClient.get(key),
+     *   set: (key, value) => myRedisClient.set(key, value),
+     *   clearExpired: () => {}
+     * }
+     */
+    storage?: {
+        get: (key: string) => {
+            count: number;
+            resetTime: number;
+        } | undefined;
+        set: (key: string, value: {
+            count: number;
+            resetTime: number;
+        }) => void;
+        clearExpired: () => void;
+    };
+    /**
+     * 🚫 Optional IP blacklist checker.
+     * Should return true if the current request’s IP is banned or suspicious.
+     * @default () => false
+     * @example
+     * isBlacklisted: (ctx) => ctx.req.remoteAddress.address === "192.168.0.10"
+     */
+    isBlacklisted?: (ctx: Context) => boolean | Promise<boolean>;
+    /**
+     * 🧠 Custom bot detector function.
+     * Use this for advanced heuristics (e.g., suspicious query params or headers).
+     * @example
+     * customBotDetector: (ctx) => ctx.query?.token === "weird"
+     */
+    customBotDetector?: (ctx: Context) => boolean | Promise<boolean>;
+    /**
+     * 🛡️ Action executed when a bot is detected.
+     * Can return a custom HTTP response (e.g., JSON, HTML, or redirect).
+     * @default Responds with 403 and JSON error.
+     * @example
+     * onBotDetected: (ctx, reason) => ctx.status(403).json({ error: `Blocked: ${reason}` })
+     */
+    onBotDetected?: (ctx: Context, reason: string) => HttpBaseResponse;
+};
+/**
+ * 🤖 Smart Bot Detection Middleware
+ *
+ * Detects automated or malicious requests using a combination of:
+ * - User-Agent analysis
+ * - IP blacklisting
+ * - Rate limiting
+ * - Custom detection logic
+ *
+ * 🧩 Supports:
+ * - Bun (uses precompiled RegExp for speed)
+ * - Node.js / Deno (optimized `includes()` loop)
+ *
+ * ⚙️ Requirements (for rate limiting):
+ * You must import `getConnInfo` from your runtime adapter:
+ * ```ts
+ * import { getConnInfo } from "tezx/bun";
+ * // or
+ * import { getConnInfo } from "tezx/node";
+ * // or
+ * import { getConnInfo } from "tezx/deno";
+ * ```
+ *
+ * 📦 Example Usage:
+ * ```ts
+ * import { detectBot } from "tezx/middleware/detectBot";
+ *
+ * app.use(detectBot({
+ *   enableRateLimiting: true,
+ *   botUserAgents: ["bot", "crawler"],
+ *   onBotDetected: (ctx, reason) => ctx.status(403).json({ error: `Bot detected: ${reason}` })
+ * }));
+ * ```
+ */
+export declare const detectBot: (opts?: DetectBotOptions) => Middleware;

package/middleware/detect-bot.js

@@ -0,0 +1,53 @@
+import { GlobalConfig } from "../core/config.js";
+import { createRateLimitDefaultStorage, isRateLimit, } from "../utils/rateLimit.js";
+import { runtime } from "../utils/runtime.js";
+export const detectBot = (opts = {}) => {
+    const botUAs = opts.botUserAgents || ["bot", "spider", "crawl", "slurp"];
+    let checkBot;
+    if (runtime === "bun") {
+        const botRegex = new RegExp(botUAs.join("|"), "i");
+        checkBot = (ua) => botRegex.test(ua);
+    }
+    else {
+        checkBot = (ua) => {
+            for (const b of botUAs)
+                if (ua.includes(b))
+                    return true;
+            return false;
+        };
+    }
+    const maxReq = opts.maxRequests || 30;
+    const winMs = opts.windowMs || 60000;
+    const enableRL = !!opts.enableRateLimiting;
+    const onBot = opts.onBotDetected ??
+        ((ctx, reason) => ctx.status(403).json({ error: `Bot detected: ${reason}` }));
+    let store = opts.storage;
+    if (enableRL && !store)
+        store = createRateLimitDefaultStorage();
+    return async (ctx, next) => {
+        const ua = ctx.headers.get("user-agent") || "";
+        if (checkBot(ua)) {
+            return onBot?.(ctx, "User-Agent");
+        }
+        if (await opts?.isBlacklisted?.(ctx)) {
+            return onBot?.(ctx, "Blacklisted IP");
+        }
+        if (enableRL) {
+            const addr = ctx.req.remoteAddress;
+            if (!addr) {
+                GlobalConfig.debugging.warn("[TezX detectBot] Missing remoteAddress. Use `getConnInfo(ctx)` to enable rate limiting.");
+            }
+            else {
+                const key = `${addr.address}:${addr.port || 0}`;
+                const { check, entry } = isRateLimit(key, store, maxReq, winMs);
+                if (check && addr.address) {
+                    return onBot?.(ctx, `Rate limit exceeded. Retry after ${Math.ceil((entry.resetTime - Date.now()) / 1000)} seconds.`);
+                }
+            }
+        }
+        if (await opts.customBotDetector?.(ctx)) {
+            return onBot?.(ctx, "Custom Detector");
+        }
+        return await next();
+    };
+};

package/middleware/i18n.d.ts

@@ -0,0 +1,194 @@
+import { Context, Middleware } from "../index.js";
+export type TranslationMap = {
+    [key: string]: string | TranslationMap;
+};
+export type loadTranslations = (language: string) => Promise<TranslationMap>;
+/**
+ * 📦 Interface defining a pluggable cache adapter for i18n translations.
+ *
+ * You can implement this interface to provide custom caching logic —
+ * for example, in-memory, Redis, file-based, or distributed cache.
+ *
+ * @example
+ * ```ts
+ * const redisCache: I18nCacheAdapter = {
+ *   async get(lang) {
+ *     const data = await redis.get(`i18n:${lang}`);
+ *     return data ? JSON.parse(data) : null;
+ *   },
+ *   async set(lang, data) {
+ *     await redis.set(`i18n:${lang}`, JSON.stringify(data), 'PX', data.expiresAt - Date.now());
+ *   },
+ *   async delete(lang) {
+ *     await redis.del(`i18n:${lang}`);
+ *   }
+ * };
+ * ```
+ */
+export interface I18nCacheAdapter {
+    /**
+     * Retrieve cached translations for a specific language.
+     *
+     * @param lang - The language code (e.g., `"en"`, `"bn"`, `"fr"`)
+     * @returns A Promise resolving to the cached translations object
+     *          or `null` if not available or expired.
+     */
+    get(lang: string): Promise<{
+        translations: TranslationMap;
+        expiresAt: number;
+    } | null>;
+    /**
+     * Store translations in cache for a specific language.
+     *
+     * @param lang - The language code (e.g., `"en"`, `"es"`)
+     * @param data - An object containing the translation map and expiration timestamp.
+     * @returns A Promise that resolves when caching is complete.
+     */
+    set(lang: string, data: {
+        translations: TranslationMap;
+        expiresAt: number;
+    }): Promise<void>;
+    /**
+     * Remove cached translations for a specific language.
+     *
+     * @param lang - The language code to delete.
+     * @returns A Promise that resolves when deletion is complete.
+     */
+    delete(lang: string): Promise<void>;
+}
+/**
+ * ⚙️ Configuration options for the TezX i18n middleware.
+ *
+ * This configuration provides flexibility for:
+ * - dynamic translation loading
+ * - custom caching strategies
+ * - language detection logic
+ * - message formatting and interpolation
+ *
+ * @example
+ * ```ts
+ * app.use(i18n({
+ *   loadTranslations: lang => import(`./locales/${lang}.json`),
+ *   detectLanguage: ctx => ctx.req.query.lang || 'en',
+ *   cacheTranslations: true,
+ *   cacheStorage: redisCache,
+ *   defaultLanguage: 'en',
+ *   formatMessage: (msg, vars) => msg.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k])
+ * }));
+ * ```
+ */
+export type I18nOptions = {
+    /**
+     * 🌐 Function responsible for loading translation data dynamically.
+     *
+     * This can load translations from local JSON, database, API, etc.
+     *
+     * @param language - Language code to load (e.g., `"en"`, `"bn-BD"`)
+     * @returns Promise resolving to translation map for that language.
+     */
+    loadTranslations: loadTranslations;
+    /**
+     * ⏱️ Default cache duration in milliseconds.
+     *
+     * Defines how long translations remain valid before reloading.
+     *
+     * @default 3600000 (1 hour)
+     */
+    defaultCacheDuration?: number;
+    /**
+     * 🔍 Function to detect the preferred user language.
+     *
+     * Determines language priority from request context.
+     * Common strategies include:
+     * - URL query parameter
+     * - Cookie
+     * - HTTP `Accept-Language` header
+     *
+     * @example
+     * detectLanguage: (ctx) => ctx.req.query.lang || ctx.cookies.lang || 'en'
+     */
+    detectLanguage: (ctx: Context) => string;
+    /**
+     * 🏠 Default fallback language.
+     *
+     * Used when detected language translations are unavailable.
+     *
+     * @default "en"
+     */
+    defaultLanguage?: string;
+    /**
+     * 🗝️ Context property key where the translation function (`t`) is attached.
+     *
+     * @default "t"
+     * @example
+     * ```ts
+     * ctx.t("greeting.hello");
+     * ctx.t("user.welcome", { name: "Rakibul" });
+     * ```
+     */
+    translationFunctionKey?: string;
+    /**
+     * 💬 Custom message formatting function.
+     *
+     * Handles variable interpolation (e.g., replacing `{{name}}` with actual value).
+     * You can override this for advanced templating logic.
+     *
+     * @param message - The base translation string.
+     * @param vars - Optional variable map for placeholders.
+     * @returns Formatted string with variables replaced.
+     *
+     * @default
+     * ```ts
+     * (msg, vars = {}) =>
+     *   Object.entries(vars).reduce(
+     *     (m, [k, v]) => m.replace(new RegExp(`{{${k}}}`, "g"), String(v)),
+     *     msg
+     *   );
+     * ```
+     */
+    formatMessage?: (message: string, vars?: Record<string, any>) => string;
+    /**
+     * 🔒 Custom cache validation logic.
+     *
+     * Checks whether cached translations are still valid.
+     *
+     * @param cached - Cached object with translations and expiry timestamp.
+     * @param lang - The language being validated.
+     * @returns `true` if cache is valid, otherwise `false`.
+     *
+     * @default
+     * ```ts
+     * (cached) => cached.expiresAt > Date.now()
+     * ```
+     */
+    isCacheValid?: (cached: {
+        translations: TranslationMap;
+        expiresAt: number;
+    }, lang: string) => boolean;
+    /**
+     * 🗃️ Whether to enable caching for translations.
+     *
+     * If disabled, translations are always loaded fresh.
+     *
+     * @default false
+     */
+    cacheTranslations?: boolean;
+    /**
+     * 💾 Optional external cache adapter for distributed or persistent caching.
+     *
+     * Supports any system implementing `I18nCacheAdapter` interface —
+     * such as Redis, filesystem, in-memory store, or custom backends.
+     *
+     * @example
+     * ```ts
+     * app.use(i18n({
+     *   loadTranslations,
+     *   cacheTranslations: true,
+     *   cacheStorage: redisCache
+     * }));
+     * ```
+     */
+    cacheStorage?: I18nCacheAdapter;
+};
+declare const i18n: (options: I18nOptions) => Middleware;
+export { i18n as default, i18n };

package/middleware/i18n.js

@@ -0,0 +1,88 @@
+import { TezXError } from "../index.js";
+const i18n = (options) => {
+    const { loadTranslations, defaultCacheDuration = 3600000, detectLanguage, defaultLanguage = "en", translationFunctionKey = "t", formatMessage = (msg, vars = {}) => {
+        if (vars && msg.indexOf("{{") !== -1) {
+            let out = "";
+            let i = 0;
+            while (i < msg.length) {
+                const startVar = msg.indexOf("{{", i);
+                if (startVar === -1) {
+                    out += msg.slice(i);
+                    break;
+                }
+                const endVar = msg.indexOf("}}", startVar + 2);
+                if (endVar === -1) {
+                    out += msg.slice(i);
+                    break;
+                }
+                out += msg.slice(i, startVar);
+                const keyVar = msg.slice(startVar + 2, endVar).trim();
+                out += vars[keyVar] !== undefined ? String(vars[keyVar]) : "";
+                i = endVar + 2;
+            }
+            return out;
+        }
+        return msg;
+    }, isCacheValid = (cached) => cached.expiresAt > Date.now(), cacheTranslations = false, cacheStorage: externalCache = null, } = options;
+    let localCache = null;
+    if (cacheTranslations && !externalCache)
+        localCache = new Map();
+    return async function i18n(ctx, next) {
+        try {
+            const lang = detectLanguage(ctx) ?? defaultLanguage;
+            let translations = undefined;
+            if (cacheTranslations) {
+                if (externalCache) {
+                    const cached = await externalCache.get(lang);
+                    if (cached && isCacheValid(cached, lang))
+                        translations = cached.translations;
+                }
+                else if (localCache?.get(lang)) {
+                    const cached = localCache.get(lang);
+                    if (isCacheValid(cached, lang))
+                        translations = cached.translations;
+                    else
+                        localCache.delete(lang);
+                }
+            }
+            if (!translations) {
+                translations = await loadTranslations(lang);
+                const expiresAt = Date.now() + defaultCacheDuration;
+                if (cacheTranslations) {
+                    if (externalCache) {
+                        await externalCache.set(lang, { translations, expiresAt });
+                    }
+                    else {
+                        localCache?.set(lang, { translations, expiresAt });
+                    }
+                }
+            }
+            ctx[translationFunctionKey] = function translate(key, vars) {
+                let acc = translations;
+                let start = 0;
+                for (let i = 0; i <= key.length; i++) {
+                    const c = key.charCodeAt(i);
+                    if (c === 46 || i === key.length) {
+                        const segment = key.slice(start, i);
+                        if (acc && typeof acc === "object") {
+                            acc = acc[segment];
+                        }
+                        else {
+                            acc = undefined;
+                            break;
+                        }
+                        start = i + 1;
+                    }
+                }
+                let msg = typeof acc === "string" ? acc : key;
+                return formatMessage(msg, vars);
+            };
+            ctx.language = lang;
+            return await next();
+        }
+        catch (error) {
+            throw new TezXError(error?.message ?? "i18n failed", 500, error?.stack);
+        }
+    };
+};
+export { i18n as default, i18n };

package/middleware/index.d.ts

@@ -1,9 +1,14 @@
 export * from "./basic-auth.js";
 export * from "./bearer-auth.js";
+export * from "./cache-control.js";
 export * from "./cors.js";
+export * from "./detect-bot.js";
+export * from "./i18n.js";
 export * from "./logger.js";
 export * from "./pagination.js";
 export * from "./powered-by.js";
+export * from "./rate-limiter.js";
 export * from "./request-id.js";
 export * from "./sanitize-headers.js";
+export * from "./secure-headers.js";
 export * from "./xss-protection.js";

package/middleware/index.js

@@ -1,9 +1,14 @@
 export * from "./basic-auth.js";
 export * from "./bearer-auth.js";
+export * from "./cache-control.js";
 export * from "./cors.js";
+export * from "./detect-bot.js";
+export * from "./i18n.js";
 export * from "./logger.js";
 export * from "./pagination.js";
 export * from "./powered-by.js";
+export * from "./rate-limiter.js";
 export * from "./request-id.js";
 export * from "./sanitize-headers.js";
+export * from "./secure-headers.js";
 export * from "./xss-protection.js";

package/middleware/logger.d.ts

@@ -15,4 +15,4 @@ import { Middleware } from "../types/index.js";
 declare function logger(options?: {
     enabled: boolean;
 }): Middleware;
-export { logger, logger as default };
+export { logger as default, logger };

package/middleware/logger.js

@@ -1,3 +1,4 @@
+import { TezXError } from "../core/error.js";
 import { colorText } from "../utils/colors.js";
 function logger(options = { enabled: true }) {
     return async function logger(ctx, next) {
@@ -15,8 +16,8 @@ function logger(options = { enabled: true }) {
         }
         catch (err) {
             console.error(`${colorText("Error:", "red")}`, err.stack);
-            throw new Error(err.stack);
+            throw new TezXError(err.stack);
         }
     };
 }
-export { logger, logger as default };
+export { logger as default, logger };

package/middleware/rate-limiter.d.ts

@@ -1,4 +1,5 @@
 import { Context } from "../core/context.js";
+import { TezXError } from "../core/error.js";
 import { HttpBaseResponse, Middleware } from "../types/index.js";
 export type RateLimiterOptions = {
     /**
@@ -41,10 +42,10 @@ export type RateLimiterOptions = {
      * @example
      * onError: (ctx, retryAfter) => {
      *   ctx.status = 429;
-     *   throw new Error( `Rate limit exceeded. Try again in ${retryAfter} seconds.`);
+     *   throw new TezXError( `Rate limit exceeded. Try again in ${retryAfter} seconds.`);
      * }
      */
-    onError?: (ctx: Context, retryAfter: number, error: Error) => HttpBaseResponse;
+    onError?: (ctx: Context, retryAfter: number, error: TezXError) => HttpBaseResponse;
 };
 /**
  * 🚦 Rate limiting middleware for request throttling

package/middleware/rate-limiter.js

@@ -23,7 +23,7 @@ const rateLimiter = (options) => {
         if (check) {
             const retryAfter = Math.ceil((entry.resetTime - Date.now()) / 1000);
             ctx.headers.set("Retry-After", retryAfter.toString());
-            return onError(ctx, retryAfter, new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
+            return onError(ctx, retryAfter, new TezXError(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
         }
         ctx.headers.set("X-RateLimit-Limit", maxRequests.toString());
         ctx.headers.set("X-RateLimit-Remaining", (maxRequests - entry.count).toString());

package/middleware/sanitize-headers.js

@@ -1,5 +1,5 @@
 const sanitizeHeaders = (options = {}) => {
-    const { whitelist = [], blacklist = [], } = options;
+    const { whitelist = [], blacklist = [] } = options;
     const normalizedWhitelist = whitelist.map((h) => h.toLowerCase());
     const normalizedBlacklist = blacklist.map((h) => h.toLowerCase());
     let lWhite = normalizedWhitelist.length;

package/middleware/secure-headers copy.d.ts

@@ -0,0 +1,15 @@
+export type SecureHeadersOptions = {
+    preset?: "strict" | "balanced" | "dev";
+    hsts?: boolean;
+    hstsMaxAge?: number;
+    frameGuard?: "DENY" | "SAMEORIGIN" | string;
+    noSniff?: boolean;
+    xssProtection?: boolean;
+    referrerPolicy?: string;
+    permissionsPolicy?: string;
+    csp?: string | Record<string, string | string[]>;
+    cspReportOnly?: boolean;
+    cspUseNonce?: boolean;
+    ultraFastMode?: boolean;
+};
+export declare const secureHeaders: <T extends Record<string, any> = {}, Path extends string = any>(userOpts?: SecureHeadersOptions) => (ctx: any, next: () => Promise<any>) => Promise<any>;