import { du as MiddlewareChain, dz as RateLimitStorage, dA as RateLimitStatus, dB as MemoryRateLimitStorageOptions, ah as MiddlewareContext, ae as FarmMiddlewareConfig, dq as MiddlewareFunction, ag as MiddlewareConfig, o as MiddlewareProps } from './client-plugins-Bz7W8EKI.mjs';
export { dv as CookieJar, dw as CookieOptions, dD as MiddlewareResult, dt as MiddlewareStore, dC as NextFunction, dx as RateLimitConfig, dy as RateLimitIncrementResult, ad as ReadonlyMiddlewareStore, dr as RequestMiddleware, ds as RequestMiddlewareContext } from './client-plugins-Bz7W8EKI.mjs';
import { IncomingMessage, ServerResponse } from 'http';
import { ViteDevServer, Plugin } from 'vite';
import { a as FarmServerConfig, R as ResolvedFarmServerConfig } from './workflows-BantWytQ.mjs';
import { R as ResolvedFarmI18nConfig } from './types-CnH8DOqo.mjs';
export { _ as _runWithMiddlewareContext, b as _runWithMiddlewareData, a as applyProductionMiddlewareHeaders, c as createProductionMiddlewareRunner, g as getMiddlewareContext, d as getMiddlewareData, e as getMiddlewareValue, m as matchesMiddlewareConfig } from './production-runtime-eRqnLz8i.mjs';
import './lifecycle-De0vQG45.mjs';
import './route-C8RuFaMN.mjs';
import './cache.mjs';
import './renderer.mjs';
import './types-Cc8l9IqS.mjs';
import 'db0';
import 'unstorage';
import './schema.mjs';
import 'react';
import './integration-api-BbaiokCC.mjs';
import '@farming-labs/orm';
import './types-CKwggz9n.mjs';
import '@farming-labs/docs';
import './markdown.mjs';
import './observability.mjs';
import '@opentelemetry/api';
import './cron.mjs';
import './env.mjs';
import './navigation-errors-Dvwpzaer.mjs';
import './server-action-security.mjs';
import './server-fn-error-DDh14a0V.mjs';
import 'esbuild';
import './image-config-Duob7wER.mjs';
import './types-DQnyD3VD.mjs';
import './font.mjs';
import './after.mjs';
import 'node:http';
import './island-CfGru1MO.mjs';

/**
 * Middleware Chain Builder
 */

declare class UnsupportedRateLimitStorageError extends TypeError {
    constructor();
}
/** Create an atomic, process-local fixed-window rate-limit store. */
declare function memoryRateLimitStorage(options?: MemoryRateLimitStorageOptions): RateLimitStorage;
/**
 * Get rate limit status for a key
 * @example
 * const status = await getRateLimitStatus('user:123', 100, storage);
 */
declare function getRateLimitStatus(key: string, limit: number, storage?: RateLimitStorage): Promise<RateLimitStatus>;
declare function middleware(basePath?: string): MiddlewareChain;

/**
 * Middleware Context Implementation
 */

/**
 * Create a middleware context from request/response
 */
declare function createContext(req: IncomingMessage, res: ServerResponse, viteServer?: ViteDevServer, parent?: MiddlewareContext["parent"], server?: FarmServerConfig | ResolvedFarmServerConfig): MiddlewareContext;

/**
 * Middleware Manager
 *
 * Discovers and executes middleware files in the file system
 */

interface DiscoveredMiddleware {
    path: string;
    filePath: string;
    handlers: MiddlewareFunction[];
    config?: MiddlewareConfig;
    source?: "config" | "file";
}
/**
 * Middleware Manager - discovers and executes middleware
 */
declare class MiddlewareManager {
    private middleware;
    private configMiddleware;
    private globalConfig?;
    private viteServer?;
    private appDirs;
    private i18n?;
    private server?;
    constructor(appDir: string | readonly string[], viteServer?: ViteDevServer, config?: FarmMiddlewareConfig, i18n?: ResolvedFarmI18nConfig, server?: FarmServerConfig | ResolvedFarmServerConfig);
    configure(config?: FarmMiddlewareConfig): void;
    /**
     * Discover all middleware.ts files
     */
    discover(): Promise<void>;
    /**
     * Recursively discover middleware files
     */
    private discoverInDirectory;
    /**
     * Find middleware file in directory
     */
    private findMiddlewareFile;
    /**
     * Load a middleware file
     */
    private loadMiddleware;
    /**
     * Execute middleware for a request
     */
    execute(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
    /**
     * Check if pathname matches middleware config
     */
    private matchesConfig;
    /**
     * Match a pattern against pathname
     */
    private matchPattern;
    /**
     * Reload middleware (for HMR)
     */
    reload(): Promise<void>;
    getMiddlewares(): DiscoveredMiddleware[];
    hasMiddleware(): boolean;
    private matchRoutePath;
    private toMatcherList;
    private getConfigHandlers;
    private toMiddlewareConfig;
    private compilePathPattern;
    private parseColonParam;
    private escapeRegex;
}

/**
 * Middleware helper utilities for pages
 */

/**
 * Unwrap middleware data from PageProps
 *
 * @example
 * ```tsx
 * export default async function Page(props: PageProps) {
 *   const { user, stats } = await unwrapMiddleware(props.middleware, {
 *     user: null,
 *     stats: { views: 0, clicks: 0 }
 *   });
 *
 *   return <div>Welcome {user?.name}</div>;
 * }
 * ```
 */
declare function unwrapMiddleware<T extends Record<string, any>>(middleware: MiddlewareProps | undefined, defaults?: Partial<T>): Partial<T>;
/**
 * Get a single value from middleware with a default
 *
 * @example
 * ```tsx
 * export default async function Page(props: PageProps) {
 *   const user = await getMiddlewareValue(props.middleware, 'user', null);
 *   return <div>Welcome {user?.name || 'Guest'}</div>;
 * }
 * ```
 */
declare function getFromMiddleware<T = any>(middleware: MiddlewareProps | undefined, key: string, defaultValue?: T): T | undefined;
/**
 * Check if middleware data exists
 */
declare function hasMiddlewareData(middleware: MiddlewareProps | undefined): boolean;

/**
 * Standalone Vite middleware support used by Farm's RSC and API plugins.
 */

interface FarmMiddlewarePluginOptions {
    /** Source directory (default: `src`). */
    srcDir?: string;
    /** Enable debug logging. */
    debug?: boolean;
}
declare function farmMiddlewarePlugin(options?: FarmMiddlewarePluginOptions): Plugin;

export { FarmMiddlewareConfig, type FarmMiddlewarePluginOptions, MemoryRateLimitStorageOptions, MiddlewareChain, MiddlewareConfig, MiddlewareContext, MiddlewareFunction, MiddlewareManager, RateLimitStatus, RateLimitStorage, UnsupportedRateLimitStorageError, createContext, farmMiddlewarePlugin, getFromMiddleware, getRateLimitStatus, hasMiddlewareData, memoryRateLimitStorage, middleware, unwrapMiddleware };