import { ad as ReadonlyMiddlewareStore, ae as FarmMiddlewareConfig, af as MiddlewareModule, ag as MiddlewareConfig, ah as MiddlewareContext } from './client-plugins-IR4yJ6w3.js';
import { R as ResolvedFarmI18nConfig } from './types-CnH8DOqo.js';
import { R as ResolvedFarmServerConfig } from './workflows-BantWytQ.js';

/**
 * Server-side middleware utilities for accessing middleware data in pages
 */

type MiddlewareStoreInput = Record<string, any> | Map<string, any>;
/**
 * Internal: Run code with middleware data available
 * This is called by the server renderer
 */
declare function _runWithMiddlewareData<T>(data: MiddlewareStoreInput, fn: () => T | Promise<T>): Promise<T>;
/** Internal: Run code with server-only middleware context available. */
declare function _runWithMiddlewareContext<T>(context: MiddlewareStoreInput, fn: () => T | Promise<T>): Promise<T>;
/**
 * Get middleware data in a server component
 * No props needed - uses global storage!
 *
 * @example
 * ```tsx
 * import { getMiddlewareData } from 'farm/middleware';
 *
 * export default function Page() {
 *   const data = getMiddlewareData();  // ← No props needed!
 *   const user = data.get('user');
 *   const demoInfo = data.get('demoInfo');
 *
 *   return <div>Welcome {user?.name}</div>;
 * }
 * ```
 */
declare function getMiddlewareData<T extends Record<string, any> = Record<string, any>>(): Map<keyof T, T[keyof T]>;
/**
 * Get a specific value from middleware data (synchronous)
 * Uses AsyncLocalStorage for request scoping - no props needed.
 *
 * @example
 * ```tsx
 * import { getMiddlewareValue } from 'farm/middleware';
 *
 * export default function Page() {
 *   const user = getMiddlewareValue<User>('user');  // ← No props needed!
 *   const stats = getMiddlewareValue('dashboardStats');
 *
 *   return <div>Welcome {user?.name}</div>;
 * }
 * ```
 */
declare function getMiddlewareValue<T = any>(key: string): T | undefined;
/**
 * Read server-only values set by route middleware for the current request.
 * The returned store is available to the matched page, layouts, and nested
 * Server Components, but is never added to hydration props.
 */
declare function getMiddlewareContext<T extends Record<string, any> = Record<string, any>>(): ReadonlyMiddlewareStore<T>;

interface ProductionMiddlewareModuleEntry {
    path: string;
    filePath?: string;
    module: MiddlewareModule | Record<string, any>;
}
interface ProductionMiddlewareRunnerOptions {
    config?: FarmMiddlewareConfig | null;
    modules?: ProductionMiddlewareModuleEntry[];
    i18n?: ResolvedFarmI18nConfig;
    server?: Pick<ResolvedFarmServerConfig, "trustProxy">;
}
interface ProductionMiddlewareResult {
    request: Request;
    response: Response | null;
    data: Map<string, any>;
    context: Map<string, any>;
    headers: Headers;
    handled: boolean;
}
/**
 * Decide whether a middleware entry's `export const config` applies to a path.
 *
 * Exported so the standalone dev plugin matches exactly what the production
 * runner does instead of maintaining a parallel implementation.
 */
declare function matchesMiddlewareConfig(pathname: string, config: MiddlewareConfig, ctx: MiddlewareContext): {
    matched: boolean;
    params?: Record<string, string>;
};
declare function createProductionMiddlewareRunner(options?: ProductionMiddlewareRunnerOptions): (request: Request) => Promise<ProductionMiddlewareResult>;
declare function applyProductionMiddlewareHeaders(response: Response, middlewareHeaders?: Headers | null): Response;

export { _runWithMiddlewareContext as _, applyProductionMiddlewareHeaders as a, _runWithMiddlewareData as b, createProductionMiddlewareRunner as c, getMiddlewareData as d, getMiddlewareValue as e, getMiddlewareContext as g, matchesMiddlewareConfig as m };