import { n as FarmClientPlugin } from './lifecycle-De0vQG45.js';
import { Z as PluginRoutes, P as PluginRoutesFactory } from './route-CZkTBD-s.js';
import { FarmRenderer } from './renderer.js';
import { IncomingMessage, ServerResponse } from 'http';
import { d as FarmStorageUserConfig } from './types-Cc8l9IqS.js';
import { FarmSchema, FarmSchemaModel, FarmSchemaField, FarmSchemaFieldType, FarmSchemaReference, FarmSchemaConstraint, FarmSchemaModelExtension, FarmSchemaModelOverride, defineSchema } from './schema.js';
import React__default, { ComponentType, ReactNode } from 'react';
import { F as FarmIntegrationAPI, e as FarmIntegrationAPIMethod, c as FarmIntegrationAPIBodyFormat, f as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, h as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes } from './integration-api-BbaiokCC.js';
import { OrmClient, SchemaDefinition, ModelDefinition, FieldBuilder, JsonValue, AnyModelDefinition, SchemaModels } from '@farming-labs/orm';
import { a as FarmDocsUserConfig, F as FarmDocsResolvedConfig } from './types-CKwggz9n.js';
import { FarmMarkdownUserConfig, FarmMarkdownResolvedConfig } from './markdown.js';
import { FarmObservabilityUserConfig } from './observability.js';
import * as vite from 'vite';
import { ViteDevServer, UserConfig, Plugin, Connect } from 'vite';
import { j as FarmWorkflowsUserConfig, a as FarmServerConfig, F as FarmWorkflowsResolvedConfig, R as ResolvedFarmServerConfig } from './workflows-BantWytQ.js';
import { FarmCronUserConfig, FarmCronResolvedConfig } from './cron.js';
import { ResolvedFarmEnv, FarmEnvConfig } from './env.js';
import { b as FarmRedirectStatus } from './navigation-errors-Dvwpzaer.js';
import { FarmServerActionsConfig, ResolvedFarmServerActionsConfig } from './server-action-security.js';
import * as esbuild from 'esbuild';
import { F as FarmImageConfig, R as ResolvedFarmImageConfig } from './image-config-Duob7wER.js';
import { k as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-CnH8DOqo.js';
import { FarmCacheUserConfig } from './cache.js';
import { R as ResolvedFarmThemeConfig, d as FarmThemeConfig } from './types-DQnyD3VD.js';
import { FarmLayoutFonts } from './font.js';
import { _withAfterNodeMiddleware } from './after.js';
import { F as FarmIslandStrategy } from './island-CfGru1MO.js';

/**
 * Agent-readiness configuration: opt-in primitives that make a Farm site easier
 * for AI agents and crawlers to discover, resolve, and use. Off by default so
 * sites that do not want agent exposure (internal tools, private dashboards) are
 * unaffected.
 */
/** schema.org JSON-LD emitted in the document head to identify the site. */
interface FarmAgentJsonLd {
    /**
     * schema.org `@type`. Common values: `"Organization"` for a company or
     * project, `"SoftwareApplication"` for a product, `"WebSite"`, `"Person"`.
     *
     * @default "Organization"
     */
    type?: string;
    /** Entity name. Defaults to the site's Open Graph site name or page title. */
    name?: string;
    /** Canonical URL for the entity. Defaults to the configured `metadataBase`. */
    url?: string;
    /** Short description. Defaults to the page/site metadata description. */
    description?: string;
    /** Logo URL. */
    logo?: string;
    /** URLs that also represent this entity (social profiles, repos) — schema.org `sameAs`. */
    sameAs?: string[];
    /** Additional schema.org properties merged into the emitted object. */
    properties?: Record<string, unknown>;
}
interface FarmAgentUserConfig {
    /**
     * Emit schema.org JSON-LD in the document head so agents and crawlers can
     * resolve the site's identity. `true` emits an `Organization` built from the
     * site's metadata; an object customizes the type and fields.
     *
     * @default false
     */
    jsonLd?: boolean | FarmAgentJsonLd;
}
interface ResolvedFarmAgentConfig {
    jsonLd: FarmAgentJsonLd | false;
}

/**
 * Integration auth routes accept ordinary form posts, which browsers send
 * cross-site without a CORS preflight. Without an origin check, a third-party
 * page can submit credentials to an app's own sign-in route and plant an
 * attacker-controlled session in the victim's browser (login CSRF), or drive a
 * forced sign-out. This mirrors the server-action origin contract so both
 * entry points reject the same requests.
 */
type IntegrationOriginRejection = "missing-origin" | "opaque-origin" | "invalid-origin" | "cross-site";
type IntegrationOriginResult = {
    ok: true;
} | {
    ok: false;
    reason: IntegrationOriginRejection;
};
interface IntegrationOriginPolicy {
    /** Extra trusted origins, using the `serverActions.allowedOrigins` pattern syntax. */
    allowedOrigins?: readonly string[];
    /**
     * Whether a request carrying no origin metadata at all must be rejected.
     *
     * Form posts always carry an Origin header in supported browsers, so
     * state-changing POSTs default to rejecting (`true`). Top-level GET
     * navigations legitimately arrive with no Origin and no Referer — a typed
     * URL or a bookmark — so GET callers pass `false` to avoid breaking them.
     */
    requireOriginMetadata?: boolean;
}
/**
 * Resolve configured origin patterns once, at integration construction, so an
 * invalid pattern fails loudly at startup instead of per request.
 */
declare function resolveIntegrationAllowedOrigins(values: readonly string[] | undefined, label: string): readonly string[];
declare function validateIntegrationRequestOrigin(request: Request, policy?: IntegrationOriginPolicy): IntegrationOriginResult;
declare function describeIntegrationOriginRejection(reason: IntegrationOriginRejection): string;

type RuntimeClientFactory<TClient> = () => TClient | Promise<TClient>;
type FarmIntegrationOrmSchema = SchemaDefinition<Record<string, AnyModelDefinition>>;
type FarmIntegrationOrmClient<TSchema extends FarmIntegrationOrmSchema> = OrmClient<TSchema>;
type FarmIntegrationOrmFieldKind<TField extends FarmIntegrationSchemaField> = TField["type"] extends "id" | "uuid" ? "id" : TField["type"] extends "text" ? "string" : TField["type"] extends "number" ? "decimal" : Extract<TField["type"], "string" | "boolean" | "integer" | "datetime" | "json" | "enum">;
type FarmIntegrationOrmFieldNullable<TField extends FarmIntegrationSchemaField> = TField extends {
    nullable: true;
} ? true : TField extends {
    required: false;
} ? true : false;
type FarmIntegrationOrmEnumValue<TField extends FarmIntegrationSchemaField> = TField extends {
    values: readonly (infer TValue extends string)[];
} ? TValue : string;
type FarmIntegrationOrmFieldValue<TField extends FarmIntegrationSchemaField> = TField["type"] extends "id" | "uuid" | "string" | "text" ? string : TField["type"] extends "boolean" ? boolean : TField["type"] extends "integer" ? number : TField["type"] extends "number" ? string : TField["type"] extends "datetime" ? Date : TField["type"] extends "json" ? JsonValue : TField["type"] extends "enum" ? FarmIntegrationOrmEnumValue<TField> : never;
type InferFarmIntegrationOrmField<TField extends FarmIntegrationSchemaField> = FieldBuilder<FarmIntegrationOrmFieldKind<TField>, FarmIntegrationOrmFieldNullable<TField>, FarmIntegrationOrmFieldValue<TField>>;
type InferFarmIntegrationOrmFields<TModel extends FarmIntegrationSchemaModel> = {
    [TFieldKey in keyof TModel["fields"] & string]: InferFarmIntegrationOrmField<Extract<TModel["fields"][TFieldKey], FarmIntegrationSchemaField>>;
};
type InferFarmIntegrationOrmSchema<TSchema extends FarmIntegrationSchema> = SchemaDefinition<{
    [TModelKey in keyof TSchema["models"] & string]: ModelDefinition<InferFarmIntegrationOrmFields<Extract<TSchema["models"][TModelKey], FarmIntegrationSchemaModel>>, {}>;
}>;
type InferFarmIntegrationOrmClient<TSchema extends FarmIntegrationSchema | undefined> = TSchema extends FarmIntegrationSchema ? OrmClient<InferFarmIntegrationOrmSchema<TSchema>> : never;
interface CreateIntegrationOrmOptions<TClient = unknown, TSchema extends FarmIntegrationSchema = FarmIntegrationSchema> {
    schema: TSchema;
    config?: Pick<FarmConfig, "storage">;
    storage?: FarmStorageUserConfig;
    client?: TClient | RuntimeClientFactory<TClient>;
}
declare function createIntegrationOrm<TClient = unknown, TSchema extends FarmIntegrationSchema = FarmIntegrationSchema>(options: CreateIntegrationOrmOptions<TClient, TSchema>): Promise<InferFarmIntegrationOrmClient<TSchema>>;
declare function resolveIntegrationOrmRuntimeClient<TClient = unknown>(options: Omit<CreateIntegrationOrmOptions<TClient>, "schema">): Promise<TClient | unknown | undefined>;
declare function farmIntegrationSchemaToOrmSchema(schema: FarmIntegrationSchema): Promise<FarmIntegrationOrmSchema>;
type IntegrationOrmModelNames<TSchema extends FarmIntegrationOrmSchema> = keyof SchemaModels<TSchema> & string;

interface ResolvedClientCacheAdapterEntry {
    /** Absolute adapter module path with forward slashes, ready for codegen. */
    importPath: string;
    options: {
        version?: string;
        flushDelayMs?: number;
    };
}
interface ClientCachePersistenceEntryCode {
    imports: string;
    init: string;
}
/**
 * Resolve `cache.client.adapter` from configuration to an absolute module
 * path for the generated client entries. Fails the build with an actionable
 * error when the option is set but the module cannot be found.
 */
declare function resolveFarmClientCacheAdapterEntry(root: string, cache: FarmCacheUserConfig | undefined): ResolvedClientCacheAdapterEntry | undefined;
/**
 * Code fragments for the generated client entries: an import of the user's
 * adapter module and an init call that runs before hydration starts. Empty
 * strings when persistence is not configured, so entries stay unchanged.
 */
declare function generateClientCachePersistenceCode(entry: ResolvedClientCacheAdapterEntry | undefined): ClientCachePersistenceEntryCode;

/**
 * Farm.js Middleware System
 *
 * Type definitions for the middleware system
 */

/**
 * Next function type for middleware chain
 */
type MiddlewareResult = void | Response;
type NextFunction = () => Promise<MiddlewareResult>;
type MiddlewareStoreKey<TValues extends Record<string, any>> = Extract<keyof TValues, string>;
/**
 * A typed view over the request-scoped maps used by middleware.
 */
interface ReadonlyMiddlewareStore<TValues extends Record<string, any> = Record<string, any>> {
    readonly size: number;
    get<TKey extends MiddlewareStoreKey<TValues>>(key: TKey): TValues[TKey] | undefined;
    has<TKey extends MiddlewareStoreKey<TValues>>(key: TKey): boolean;
    entries(): IterableIterator<[MiddlewareStoreKey<TValues>, TValues[MiddlewareStoreKey<TValues>]]>;
    keys(): IterableIterator<MiddlewareStoreKey<TValues>>;
    values(): IterableIterator<TValues[MiddlewareStoreKey<TValues>]>;
    forEach(callback: (value: TValues[MiddlewareStoreKey<TValues>], key: MiddlewareStoreKey<TValues>, store: ReadonlyMiddlewareStore<TValues>) => void, thisArg?: any): void;
    [Symbol.iterator](): IterableIterator<[
        MiddlewareStoreKey<TValues>,
        TValues[MiddlewareStoreKey<TValues>]
    ]>;
}
interface MiddlewareStore<TValues extends Record<string, any> = Record<string, any>> extends ReadonlyMiddlewareStore<TValues> {
    clear(): void;
    delete<TKey extends MiddlewareStoreKey<TValues>>(key: TKey): boolean;
    set<TKey extends MiddlewareStoreKey<TValues>>(key: TKey, value: TValues[TKey]): this;
}
/**
 * Middleware function signature
 */
type MiddlewareFunction = (ctx: MiddlewareContext, next: NextFunction) => MiddlewareResult | Promise<MiddlewareResult>;
/**
 * Context passed to a named, request-first middleware export.
 * `locals` and the get/set helpers stay on the server. `data` can be exposed
 * through page props and should contain only serializable, client-safe values.
 */
interface RequestMiddlewareContext<TLocals extends Record<string, any> = Record<string, any>, TData extends Record<string, any> = Record<string, any>> {
    readonly url: URL;
    readonly pathname: string;
    readonly searchParams: URLSearchParams;
    readonly method: string;
    readonly params: Record<string, string>;
    readonly route: string;
    readonly locals: MiddlewareStore<TLocals>;
    readonly data: MiddlewareStore<TData>;
    readonly headers: Map<string, string>;
    readonly cookies: CookieJar;
    get<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): TLocals[TKey] | undefined;
    has<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
    set<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey, value: TLocals[TKey]): void;
    delete<TKey extends MiddlewareStoreKey<TLocals>>(key: TKey): boolean;
    redirect(url: string, status?: number): void;
    rewrite(url: string): void;
    json(data: any, status?: number): void;
    text(content: string, status?: number): void;
    html(content: string, status?: number): void;
}
type RequestMiddleware<TLocals extends Record<string, any> = Record<string, any>, TData extends Record<string, any> = Record<string, any>> = (request: Request, context: RequestMiddlewareContext<TLocals, TData>) => MiddlewareResult | Promise<MiddlewareResult>;
/**
 * Cookie options
 */
interface CookieOptions {
    maxAge?: number;
    expires?: Date;
    path?: string;
    domain?: string;
    secure?: boolean;
    httpOnly?: boolean;
    sameSite?: "strict" | "lax" | "none";
}
/**
 * Cookie management interface
 */
interface CookieJar {
    get(name: string): string | undefined;
    set(name: string, value: string, options?: CookieOptions): void;
    /**
     * Remove a cookie. Pass the `path`/`domain` it was set with; a tombstone only
     * matches a cookie with the same scope.
     */
    delete(name: string, options?: CookieOptions): void;
    getAll(): Record<string, string>;
}
interface RateLimitIncrementResult {
    count: number;
    /** Unix epoch timestamp in milliseconds when the fixed window resets. */
    resetAt: number;
}
interface RateLimitStorage {
    /** Atomically increment a key and create or retain its fixed expiry window. */
    increment(key: string, windowMs: number): Promise<RateLimitIncrementResult> | RateLimitIncrementResult;
    /** Optional inspection support used by getRateLimitStatus(). */
    get?(key: string): Promise<RateLimitIncrementResult | null> | RateLimitIncrementResult | null;
}
interface MemoryRateLimitStorageOptions {
    /** Maximum number of active keys retained by this process. */
    maxEntries?: number;
}
interface RateLimitConfig {
    requests: number;
    window: string;
    keyGenerator?: (ctx: MiddlewareContext) => string;
    onLimit?: (ctx: MiddlewareContext) => void | Response | Promise<void | Response>;
    storage?: RateLimitStorage;
}
interface RateLimitStatus {
    requests: number;
    limit: number;
    remaining: number;
    resetIn: number | null;
    resetAt: Date | null;
    isLimited: boolean;
}
/**
 * Middleware configuration
 */
type MiddlewareMatcher = string | RegExp | ((ctx: MiddlewareContext) => boolean);
interface MiddlewareConfig$1 {
    matcher?: MiddlewareMatcher | MiddlewareMatcher[];
    exclude?: (string | RegExp)[];
    runtime?: "nodejs" | "edge";
}
interface MiddlewareConfigEntry extends MiddlewareConfig$1 {
    handler?: MiddlewareFunction;
    handlers?: MiddlewareFunction[];
}
type FarmMiddlewareConfig = MiddlewareConfig$1 | MiddlewareConfigEntry | MiddlewareConfigEntry[];
/**
 * Middleware context - the main object passed to middleware functions
 */
interface MiddlewareContext {
    request: IncomingMessage;
    response: ServerResponse;
    url: URL;
    pathname: string;
    searchParams: URLSearchParams;
    method: string;
    params: Record<string, string>;
    route: string;
    parent?: {
        data: Map<string, any>;
        locals?: Map<string, any>;
        headers: Record<string, string>;
    };
    vite: {
        isDev: boolean;
        hmr: boolean;
        server?: ViteDevServer;
    };
    data: Map<string, any>;
    locals: Map<string, any>;
    headers: Map<string, string>;
    cookies: CookieJar;
    _handled: boolean;
    _redirectUrl?: string;
    _rewriteUrl?: string;
    redirect(url: string, status?: number): void;
    rewrite(url: string): void;
    json(data: any, status?: number): void;
    text(content: string, status?: number): void;
    html(content: string, status?: number): void;
}
/**
 * Middleware chain interface
 */
interface MiddlewareChain {
    use(fn: MiddlewareFunction): MiddlewareChain;
    /**
     * Conditionally run middleware based on a condition.
     * Supports boolean values or functions that evaluate to boolean.
     *
     * @example
     * .when(true, (ctx, next) => { ... })  // Always run
     * .when((ctx) => ctx.data.get('flag'), (ctx, next) => { ... })  // Conditional
     */
    when(condition: boolean | ((ctx: MiddlewareContext) => boolean), fn: MiddlewareFunction | ((chain: MiddlewareChain) => void)): MiddlewareChain;
    rateLimit(config: RateLimitConfig): MiddlewareChain;
    redirect(source: string, destination: string, permanent?: boolean): MiddlewareChain;
    /**
     * Rewrite the current route to a new destination.
     * In route-specific middleware, this rewrites the middleware's route.
     *
     * @param destination - The destination path to rewrite to
     * @param condition - Optional boolean or function that evaluates to boolean. If false, rewrite is skipped.
     *
     * @example
     * // In /contact/middleware.ts
     * .rewrite('/about')  // Always rewrites /contact to /about
     * .rewrite('/about', true)  // Always rewrites
     * .rewrite('/about', false)  // Never rewrites
     * .rewrite('/about', (ctx) => ctx.data.get('shouldRewrite'))  // Conditional rewrite
     */
    rewrite(destination: string, condition?: boolean | ((ctx: MiddlewareContext) => boolean)): MiddlewareChain;
    build(): {
        handlers: MiddlewareFunction[];
        config?: MiddlewareConfig$1;
    };
}
/**
 * Middleware module export
 */
interface MiddlewareModule {
    default?: MiddlewareChain | MiddlewareFunction;
    middleware?: RequestMiddleware;
    config?: MiddlewareConfig$1;
}

type FarmMdxComponent = React__default.ComponentType<any> | keyof React__default.JSX.IntrinsicElements;
type FarmMdxComponents = Record<string, FarmMdxComponent>;
interface FarmMdxUserConfig {
    /**
     * Component map or module path that exports `components` or a default component map.
     * Relative paths resolve from the project root.
     */
    components?: string | FarmMdxComponents;
    /**
     * Serve source-authored markdown pages at `/route.md`.
     * Enabled by default for `page.md` and `page.mdx`.
     */
    markdownRoutes?: boolean;
    /** Class name used for the wrapper around rendered markdown content. */
    className?: string;
}
interface FarmMdxResolvedConfig {
    components?: string | FarmMdxComponents;
    markdownRoutes: boolean;
    className: string;
}
declare function resolveMdxConfig(config: FarmMdxUserConfig | undefined): FarmMdxResolvedConfig;

type FarmRouteRuntime = "auto" | "node" | "edge";
type FarmRouteRegions = "auto" | readonly string[];
type FarmRouteMaxDuration = "auto" | number;
/** Portable execution controls shared by file, programmatic, and config routes. */
interface FarmRouteRuntimeConfig {
    runtime?: FarmRouteRuntime;
    regions?: FarmRouteRegions;
    maxDuration?: FarmRouteMaxDuration;
}
interface ResolvedFarmRouteRuntimeConfig {
    runtime: FarmRouteRuntime;
    regions?: string[];
    maxDuration?: number;
}
type FarmRouteRuntimeEntryKind = "page" | "api" | "metadata" | "rule";
type FarmRouteRenderingMode = "static" | "dynamic";
interface FarmRouteRuntimeManifestEntry extends ResolvedFarmRouteRuntimeConfig {
    kind: FarmRouteRuntimeEntryKind;
    pattern: string;
    rendering: FarmRouteRenderingMode;
    source?: string;
}
interface FarmRouteRuntimeManifest {
    version: 1;
    routes: FarmRouteRuntimeManifestEntry[];
}
declare function normalizeFarmRouteRuntimeConfig(value: FarmRouteRuntimeConfig | null | undefined, source?: string): FarmRouteRuntimeConfig;
/** Merge from lowest to highest precedence. Explicit "auto" values reset inherited hints. */
declare function mergeFarmRouteRuntimeConfigs(...configs: Array<FarmRouteRuntimeConfig | null | undefined>): FarmRouteRuntimeConfig;
declare function resolveFarmRouteRuntimeConfig(config: FarmRouteRuntimeConfig | null | undefined, source?: string): ResolvedFarmRouteRuntimeConfig;
declare function hasFarmRouteRuntimeControls(config: FarmRouteRuntimeConfig | null | undefined): boolean;
declare function getFarmRouteRuntimeConfig(value: unknown): FarmRouteRuntimeConfig;
declare function createFarmRouteRuntimeKey(config: ResolvedFarmRouteRuntimeConfig): string;
/** Resolve matching route rules from broadest to most specific. */
declare function resolveFarmRouteRuleRuntimeConfig(pathname: string, routeRules: Record<string, FarmRouteRuntimeConfig> | null | undefined): FarmRouteRuntimeConfig;
declare function farmRouteRuleMatches(pattern: string, pathname: string): boolean;

type FarmRouteRuleRenderMode = "static" | "dynamic";
type FarmRouteRuleRedirect = string | {
    to: string;
    statusCode?: FarmRedirectStatus;
    permanent?: boolean;
};
type FarmRouteRuleCors = boolean | {
    origin?: string;
    methods?: string | readonly string[];
    headers?: string | readonly string[];
};
interface FarmRouteRule extends FarmRouteRuntimeConfig {
    prerender?: boolean;
    render?: FarmRouteRuleRenderMode;
    ssr?: boolean;
    swr?: boolean | number;
    isr?: boolean | number;
    cors?: FarmRouteRuleCors;
    headers?: Record<string, string>;
    redirect?: FarmRouteRuleRedirect;
}
type FarmRouteRules = Record<string, FarmRouteRule>;
declare function normalizeRouteRules(routeRules: FarmRouteRules | undefined): FarmRouteRules;
declare function routeRulesToRedirects(routeRules: FarmRouteRules): RedirectConfig[];
declare function routeRulesToHeaders(routeRules: FarmRouteRules): HeaderConfig[];
declare function routeRulesToNitroRouteRules(routeRules: FarmRouteRules): Record<string, any>;

type EsbuildTransform = (typeof esbuild)["transform"];
type FarmLayerEntry = string;
interface ResolvedFarmLayer {
    /** The value used in `extends`. */
    source: string;
    /** Stable name used by the `#layers/<name>` alias. */
    name: string;
    /** Absolute layer package or directory root. */
    root: string;
    /** Source directory relative to the layer root. */
    srcDir: string;
    /** Resolved layer config file when one exists. */
    configFile?: string;
}
interface FarmSourceRoot {
    name: string;
    root: string;
    srcDir: string;
    layer: boolean;
}
interface ResolveFarmLayersOptions {
    root: string;
    mode: "development" | "production";
}
interface FarmLayerResolution<TConfig extends Record<string, any>> {
    config: TConfig & {
        extends?: readonly FarmLayerEntry[];
        layers: ResolvedFarmLayer[];
    };
    layers: ResolvedFarmLayer[];
}
declare function resolveFarmLayers<TConfig extends Record<string, any>>(projectConfig: TConfig, options: ResolveFarmLayersOptions): Promise<FarmLayerResolution<TConfig>>;
declare function getFarmSourceRoots(config: {
    root?: string;
    srcDir?: string;
    layers?: readonly ResolvedFarmLayer[];
}): FarmSourceRoot[];
declare function getFarmAppDirectories(config: {
    root?: string;
    srcDir?: string;
    layers?: readonly ResolvedFarmLayer[];
}): string[];
declare function getFarmLayerAliases(layers: readonly ResolvedFarmLayer[] | undefined): Record<string, string>;
declare function createFarmConfigResolutionPlugin(options: {
    transform: EsbuildTransform;
}): esbuild.Plugin;
declare function loadFarmConfigFile<TConfig = Record<string, any>>(configPath: string, options: {
    root: string;
    cacheRoot?: string;
}): Promise<TConfig>;

declare const DEFAULT_FARM_DEVTOOLS_SHORTCUT = "mod+shift+.";
declare const FARM_DEVTOOLS_PATH = "/__farm/devtools";
declare const FARM_DEVTOOLS_LAUNCH_PARAM = "__farm_devtools";
/**
 * Configuration for the built-in DevTools dashboard. The dashboard is deprecated in favor
 * of the `@farm.js/devtools` plugin, which reuses this configuration for enablement and
 * the keyboard shortcut. Both options keep working while the built-in UI remains available.
 */
interface FarmDevtoolsConfig {
    /** Enable the development-only DevTools UI and runtime endpoints. */
    enabled?: boolean;
    /** Keyboard shortcut used to toggle DevTools, or false to disable the shortcut. */
    shortcut?: string | false;
}
type FarmDevtoolsUserConfig = boolean | FarmDevtoolsConfig;
interface ResolvedFarmDevtoolsConfig {
    enabled: boolean;
    shortcut: string | false;
}
declare function resolveFarmDevtoolsConfig(config: FarmDevtoolsUserConfig | ResolvedFarmDevtoolsConfig | undefined, mode?: "development" | "production"): ResolvedFarmDevtoolsConfig;

type FarmBuildActivityPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
interface FarmDevIndicatorsConfig {
    /** Show build and HMR activity in the browser during development. */
    buildActivity?: boolean;
    /** Corner used by the build activity indicator. */
    buildActivityPosition?: FarmBuildActivityPosition;
}
interface ResolvedFarmDevIndicatorsConfig {
    buildActivity: boolean;
    buildActivityPosition: FarmBuildActivityPosition;
}
declare function resolveFarmDevIndicatorsConfig(config: FarmDevIndicatorsConfig | undefined, mode?: "development" | "production"): ResolvedFarmDevIndicatorsConfig;
declare function generateFarmDevIndicatorsClientRuntime(config: ResolvedFarmDevIndicatorsConfig): string;

interface FarmAuthEmailAndPasswordConfig {
    /** Require a verified email before creating a session. @default false */
    requireEmailVerification?: boolean;
    /** Smallest accepted password length. @default 8 */
    minPasswordLength?: number;
    /** Largest accepted password length. @default 128 */
    maxPasswordLength?: number;
}
interface FarmAuthSessionConfig {
    /** Session lifetime in seconds. @default 604800 */
    expiresIn?: number;
    /** Session refresh interval in seconds. @default 86400 */
    updateAge?: number;
}
interface FarmAuthDatabaseConfig {
    /**
     * Postgres connection string. Defaults to DATABASE_URL.
     * Local development falls back to SQLite when no URL is present.
     */
    url?: string;
    /** Local SQLite path. @default ".farm/auth.sqlite" */
    path?: string;
    /** Automatically update the auth schema in development. @default true */
    migrateInDevelopment?: boolean;
}
interface FarmAuthConfig {
    /** Set false to disable auth without removing its configuration. @default true */
    enabled?: boolean;
    /** Display name used by authentication emails and metadata. */
    appName?: string;
    /** Route prefix for the auth endpoints. @default "/api/auth" */
    basePath?: string;
    /**
     * Email/password authentication. It is enabled by default; set false to
     * disable it when adding another sign-in method.
     */
    emailAndPassword?: boolean | FarmAuthEmailAndPasswordConfig;
    session?: FarmAuthSessionConfig;
    database?: FarmAuthDatabaseConfig;
}
type FarmAuthUserConfig = boolean | FarmAuthConfig;
interface ResolvedFarmAuthConfig {
    enabled: boolean;
    appName?: string;
    basePath: string;
    emailAndPassword: {
        enabled: boolean;
        requireEmailVerification: boolean;
        minPasswordLength: number;
        maxPasswordLength: number;
    };
    session: {
        expiresIn: number;
        updateAge: number;
    };
    database: {
        url?: string;
        path: string;
        migrateInDevelopment: boolean;
    };
}

type FarmPreloadMode = "warn" | "enforce";
interface FarmPreloadUserConfig {
    /** Report excess hints or remove the lower-priority hints. @default "enforce" */
    mode?: FarmPreloadMode;
    /** Maximum image preload hints per document. @default 1 */
    maxImages?: number;
    /** Maximum font preload hints per document. @default 2 */
    maxFonts?: number;
}
interface ResolvedFarmPreloadConfig {
    mode: FarmPreloadMode;
    maxImages: number;
    maxFonts: number;
}
interface FarmPerformanceConfig {
    preload?: FarmPreloadUserConfig;
}
interface ResolvedFarmPerformanceConfig {
    preload: ResolvedFarmPreloadConfig;
}
type FarmPreloadKind = "image" | "font";
interface FarmPreloadBudgetWarning {
    kind: FarmPreloadKind;
    count: number;
    budget: number;
    removed: number;
}
interface FarmManagedPreloads {
    value: string;
    warnings: FarmPreloadBudgetWarning[];
}
interface FarmManagedDocumentPreloads {
    html: string;
    linkHeader: string;
    warnings: FarmPreloadBudgetWarning[];
}
/**
 * Apply image and font budgets to HTML preload elements. High-priority image
 * hints are retained before ordinary hints, making an explicitly preloaded LCP
 * image the winner when a document contains too many React-generated hints.
 */
declare function manageFarmHtmlPreloads(html: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
/** Apply the same budgets to HTTP Link preload hints, including Farm fonts. */
declare function manageFarmLinkHeaderPreloads(value: string, config: ResolvedFarmPreloadConfig): FarmManagedPreloads;
/** Apply a single document budget across HTML and HTTP Link header hints. */
declare function manageFarmDocumentPreloads(html: string, linkHeader: string, config: ResolvedFarmPreloadConfig): FarmManagedDocumentPreloads;
/** Rate-limit identical route-and-budget warnings within a server process. */
declare function reportFarmPreloadWarnings(warnings: FarmPreloadBudgetWarning[], context?: string): void;

type FarmCspDirectiveValue = string | readonly string[] | boolean | null | undefined;
type FarmCspDirectives = Readonly<Record<string, FarmCspDirectiveValue>>;
interface FarmCspOptions {
    /** A pre-serialized CSP value. Cannot be combined with directives. */
    policy?: string;
    /** CSP directives using camelCase or kebab-case names. */
    directives?: FarmCspDirectives;
    /** Emit Content-Security-Policy-Report-Only instead of enforcing the policy. */
    reportOnly?: boolean;
}
type FarmCspConfig = string | FarmCspOptions;
interface FarmSecurityConfig {
    /** App-wide Content Security Policy applied to pages, APIs, and static output. */
    csp?: FarmCspConfig | false;
    /** @deprecated Use csp. */
    contentSecurityPolicy?: never;
}
interface ResolvedFarmCspConfig {
    value: string;
    reportOnly: boolean;
}
interface ResolvedFarmSecurityConfig {
    csp: ResolvedFarmCspConfig | false;
}

declare const DEFAULT_FARM_API_BASE_PATH = "/api";
interface FarmAPIConfigResolverContext {
    root: string;
    mode: "development" | "production";
    env: ResolvedFarmEnv;
}
type FarmAPIConfigValue = string | undefined | ((context: FarmAPIConfigResolverContext) => string | undefined | Promise<string | undefined>);
interface FarmAPIConfig {
    /**
     * Public API root. An origin-only URL is joined with `basePath`; a URL that
     * already has a path is used as-is. May be resolved from deployment context.
     */
    baseURL?: FarmAPIConfigValue;
    /** Public API path and same-origin server mount used when `baseURL` has no path. @default "/api" */
    basePath?: FarmAPIConfigValue;
}
interface ResolvedFarmAPIConfig {
    /** Fully resolved public API root, either absolute or root-relative. */
    baseURL: string;
    /** Effective pathname of `baseURL`. */
    basePath: string;
}
declare function resolveFarmAPIConfig(config: FarmAPIConfig | undefined, context: FarmAPIConfigResolverContext): Promise<ResolvedFarmAPIConfig>;
/** Normalize already-resolved API strings. */
declare function normalizeFarmAPIConfig(config: {
    baseURL?: string;
    basePath?: string;
} | undefined): ResolvedFarmAPIConfig;
declare function normalizeFarmAPIBasePath(value: string): string;
/** Read the API root embedded by Farm's Vite build. */
declare function getFarmAPIBaseURL(): string;
/** Resolve a canonical Farm route such as `/api/users` against an API root. */
declare function resolveFarmAPIRequestURL(routePath: string, baseURL?: string, fallbackOrigin?: string): URL;

declare const FARM_RESOLVED_CUSTOM_CONTEXT: unique symbol;

interface RedirectConfig {
    source: string;
    destination: string;
    permanent?: boolean;
    statusCode?: FarmRedirectStatus;
}
interface HeaderConfig {
    source: string;
    headers: Array<{
        key: string;
        value: string;
    }>;
}
interface RewriteConfig {
    source: string;
    destination: string;
}
/** @deprecated Use FarmImageConfig. */
type ImageConfig = FarmImageConfig;
/** @deprecated Use FarmI18nUserConfig. */
type I18nConfig = FarmI18nUserConfig;
interface OpenAPIConfig {
    enabled?: boolean;
    route?: string;
    /**
     * Path where the raw OpenAPI spec is served as JSON, so agents and API tools
     * can fetch it at a predictable URL. Set to `false` to disable.
     *
     * @default "/openapi.json"
     */
    specRoute?: string | false;
    title?: string;
    description?: string;
    version?: string;
    servers?: Array<{
        url: string;
        description?: string;
    }>;
    contact?: {
        name?: string;
        email?: string;
        url?: string;
    };
    license?: {
        name: string;
        url?: string;
    };
}
type MiddlewareConfig = FarmMiddlewareConfig;
interface NotFoundConfig {
    /** Path to a custom 404 page component (e.g., "./src/app/not-found.tsx") */
    component?: string;
}
type FarmDeployTarget = "vercel" | "cloudflare" | "netlify" | "node" | string;
interface FarmDeployConfig {
    /**
     * Deployment platform. When present, Farm picks the matching Nitro preset and
     * output directory unless explicitly overridden.
     */
    target?: FarmDeployTarget;
    /** Nitro preset override. Usually inferred from target. */
    preset?: FarmConfig["preset"];
    /** Deployable output directory, relative to project root unless absolute. */
    outputDir?: string;
    /** Alias for outputDir for terser config. */
    output?: string;
    /** Cloudflare Pages project name used by `farm deploy --cloudflare`. */
    projectName?: string;
    vercel?: {
        outputDirectory?: string;
        buildCommand?: string;
        installCommand?: string;
        framework?: string | null;
    };
    cloudflare?: {
        outputDir?: string;
        projectName?: string;
    };
    netlify?: {
        outputDir?: string;
        site?: string;
    };
}
interface ResolvedFarmDeployConfig extends Omit<FarmDeployConfig, "output"> {
    target?: FarmDeployTarget;
    preset: FarmConfig["preset"];
    outputDir: string;
}
interface FarmUserConfig extends Omit<FarmConfig, "vite" | "docs" | "env" | "layers"> {
    /** Reusable Farm directories or installed packages, applied from left to right. */
    extends?: readonly FarmLayerEntry[];
    /** Global plugins. Integration-bound plugins must be contributed through an integration. */
    plugins?: FarmPlugin<any, any, any, any, unknown, false>[];
    integrations?: FarmIntegrationsUserConfig;
    /**
     * Farm-native authentication. `true` enables email/password auth with
     * server helpers from `@farm.js/auth/server` and React APIs from
     * `@farm.js/auth/client`.
     */
    auth?: FarmAuthUserConfig;
    /** Shared application data, route, ISR, and PPR cache. */
    cache?: FarmCacheUserConfig;
    migrations?: FarmMigrationsUserConfig;
    /** Map portable cron schedules to ordinary GET API routes. */
    cron?: FarmCronUserConfig | FarmCronResolvedConfig | false;
    workflows?: FarmWorkflowsUserConfig | boolean;
    preset?: FarmConfig["preset"];
    deploy?: FarmDeployConfig;
    docs?: FarmDocsUserConfig;
    md?: FarmMarkdownUserConfig | boolean;
    mdx?: FarmMdxUserConfig;
    observability?: FarmObservabilityUserConfig;
    trailingSlash?: boolean;
    redirects?: () => Promise<RedirectConfig[]> | RedirectConfig[];
    rewrites?: () => Promise<RewriteConfig[]> | RewriteConfig[];
    headers?: () => Promise<HeaderConfig[]> | HeaderConfig[];
    images?: ImageConfig;
    publicDir?: string;
    i18n?: FarmI18nUserConfig | false;
    openapi?: OpenAPIConfig;
    middleware?: FarmMiddlewareConfig;
    routeRules?: FarmRouteRules;
    context?: FarmConfig["context"];
    /** Server ingress and trusted-proxy policy. */
    server?: FarmServerConfig;
    serverActions?: FarmServerActionsConfig;
    /** Build identifier used to detect and recover from deployment version skew. */
    deploymentId?: string;
    notFound?: NotFoundConfig;
    distDir?: string;
    generateBuildId?: () => string | Promise<string>;
    compress?: boolean;
    devIndicators?: FarmDevIndicatorsConfig;
    serverRuntimeConfig?: Record<string, any>;
    publicRuntimeConfig?: Record<string, any>;
    env?: FarmEnvConfig<any, any>;
    vite?: UserConfig | ((config: UserConfig) => UserConfig);
    [key: string]: any;
}
interface ResolvedFarmConfig extends Required<Omit<FarmUserConfig, "extends" | "plugins" | "vite" | "deploy" | "docs" | "md" | "mdx" | "migrations" | "cron" | "workflows" | "api" | "env" | "server" | "serverActions" | "devtools" | "devIndicators" | "images" | "i18n" | "auth" | "performance" | "security" | "theme" | "renderer" | "agent">> {
    agent: ResolvedFarmAgentConfig;
    /** @internal Tracks whether `context` came from user/layer config instead of the default noop. */
    [FARM_RESOLVED_CUSTOM_CONTEXT]?: boolean;
    root: string;
    extends: readonly FarmLayerEntry[];
    layers: ResolvedFarmLayer[];
    plugins: FarmPlugin[];
    vite: UserConfig;
    deploy: ResolvedFarmDeployConfig;
    docs: FarmDocsResolvedConfig;
    md: FarmMarkdownResolvedConfig;
    mdx: FarmMdxResolvedConfig;
    migrations: ResolvedFarmMigrationsConfig;
    cron: FarmCronResolvedConfig;
    workflows: FarmWorkflowsResolvedConfig;
    api: ResolvedFarmAPIConfig;
    env: ResolvedFarmEnv;
    server: ResolvedFarmServerConfig;
    serverActions: ResolvedFarmServerActionsConfig;
    devtools: ResolvedFarmDevtoolsConfig;
    devIndicators: ResolvedFarmDevIndicatorsConfig;
    images: ResolvedFarmImageConfig;
    i18n: ResolvedFarmI18nConfig;
    auth: ResolvedFarmAuthConfig;
    performance: ResolvedFarmPerformanceConfig;
    security: ResolvedFarmSecurityConfig;
    theme: ResolvedFarmThemeConfig;
    renderer: FarmRenderer;
    routeRules: FarmRouteRules;
    notFound: NotFoundConfig;
}
type FarmLayerConfig = Omit<FarmUserConfig, "root" | "outDir" | "distDir" | "deploy" | "preset" | "publicDir" | "generateBuildId" | "deploymentId">;

declare function normalizeDeployTarget(target?: FarmDeployTarget): FarmDeployTarget | undefined;
declare function getPresetForDeployTarget(target?: FarmDeployTarget): FarmConfig["preset"] | undefined;
declare function getDeployTargetForPreset(preset?: string): FarmDeployTarget | undefined;
declare function resolveDeployOutputPath(root: string, outputDir: string): string;
declare function resolveDeployConfig(config: Pick<FarmUserConfig, "deploy" | "preset" | "distDir">, overrides?: {
    target?: FarmDeployTarget;
    preset?: FarmConfig["preset"];
    outputDir?: string;
    /** Build environment consulted for platform detection. Tests inject this. */
    env?: NodeJS.ProcessEnv;
}): ResolvedFarmDeployConfig;
declare function resolveMigrationsConfig(migrations: FarmMigrationsUserConfig | undefined): ResolvedFarmMigrationsConfig;
declare function resolveConfig(userConfig: FarmUserConfig, mode: "development" | "production"): Promise<ResolvedFarmConfig>;
declare function loadConfig(rootDir?: string, configPath?: string, mode?: string, loadEnvironment?: (typeof vite)["loadEnv"]): Promise<FarmUserConfig | undefined>;

/** Browser-safe bridge: neither handlers nor Node.js imports cross this boundary. */
interface APIRequestRuntime {
    basePath: string;
    dispatch(request: Request): Promise<Response>;
}

interface FarmVitePluginOptions extends FarmConfig {
    openapi?: FarmUserConfig["openapi"];
    images?: FarmUserConfig["images"];
    publicDir?: FarmUserConfig["publicDir"];
    /** @internal Modules selected by the compiled isolated-hydration ownership plan. */
    isolatedClientBoundaryModules?: ReadonlySet<string>;
}
declare function farmI18nClientBridgePlugin(): Plugin;

/** Exported for tests: the request boundary all Farm dev middlewares share. */
declare function withFarmRequestTracing(handler: Parameters<typeof _withAfterNodeMiddleware>[0], apiRuntime?: APIRequestRuntime, resolveTraceUrl?: (request: Connect.IncomingMessage) => URL): Connect.NextHandleFunction;
interface FarmModuleAstNode {
    type: string;
    start: number;
    end: number;
    [key: string]: unknown;
}
declare function rewriteEarlySsrRelativeImports(options: {
    code: string;
    id: string;
    root: string;
    parse: (code: string) => FarmModuleAstNode;
}): string | null;
declare function transformIsolatedClientBoundaryModule(options: {
    code: string;
    moduleReference: string;
    islandStrategy: FarmIslandStrategy;
    parse: (code: string) => FarmModuleAstNode;
}): string | null;
/**
 * Whether Farm should append its own client-root HMR handler to a
 * `"use client"` module.
 *
 * Re-rendering the whole root on every edit only makes sense for a renderer
 * that diffs the result against the live DOM. On Solid and Svelte `render()`
 * tears the tree down and rebuilds it, so a one character change in any client
 * component would wipe the page's state. Those renderers ship their own HMR
 * integration (solid-refresh, svelte's hot API) which preserves component
 * state, and appending an `import.meta.hot.accept` here would swallow the
 * update before theirs could run.
 */
declare function shouldEmitFarmClientRootHmr(renderer?: FarmRenderer): boolean;
declare function farmPlugin(options?: FarmVitePluginOptions, initialPluginManager?: PluginManager): Plugin;
declare function defineConfig(config?: FarmVitePluginOptions): Promise<UserConfig>;

type MaybePromise$1<T> = T | Promise<T>;
/** @internal Marks a Node response whose intercepted end is awaiting response hooks. */
declare const FARM_NODE_RESPONSE_END_PENDING: unique symbol;
declare const FARM_PLUGIN_INTEGRATION_INSTANCE: unique symbol;
declare const FARM_PLUGIN_INTEGRATION_BOUND: unique symbol;
interface FarmPluginIntegrationContext<TInstance = unknown> {
    /** Key used to register the integration in farm.config.ts. */
    readonly key: string;
    readonly category: string;
    readonly type: string;
    readonly instance: TInstance;
    readonly serverRuntime: boolean;
}
declare class FarmRuntimeShutdownError extends Error {
    readonly errors: readonly unknown[];
    constructor(message: string, errors: readonly unknown[]);
}
interface PluginRequestContext {
    set: (target: FarmRequest | Request, key: string, value: any, options?: {
        exposeToPage?: boolean;
    }) => void;
    get: <T = any>(target: FarmRequest | Request, key: string) => T | undefined;
    has: (target: FarmRequest | Request, key: string) => boolean;
    delete: (target: FarmRequest | Request, key: string) => boolean;
    clear: (target: FarmRequest | Request) => void;
    getAll: (target: FarmRequest | Request, options?: {
        exposedOnly?: boolean;
    }) => Map<string, any>;
}
interface FarmRequestStore {
    set(key: string, value: unknown, options?: {
        exposeToPage?: boolean;
    }): void;
    get<T = unknown>(key: string): T | undefined;
    has(key: string): boolean;
    delete(key: string): boolean;
    clear(): void;
    snapshot(options?: {
        exposedOnly?: boolean;
    }): Map<string, unknown>;
}
interface FarmPluginContext<TIntegrationInstance = unknown> {
    config: FarmConfig;
    viteServer?: ViteDevServer;
    isDev: boolean;
    isProd: boolean;
    /** The owning integration when this plugin is contributed through `integration.plugins`. */
    readonly integration?: Readonly<FarmPluginIntegrationContext<TIntegrationInstance>>;
    /** Register resource cleanup that must run when the application runtime closes. */
    lifecycle: FarmPluginLifecycle;
    /** @deprecated Use `ctx.req` inside request hooks. */
    requestContext: PluginRequestContext;
}
type FarmPluginHookContext<TContext, TIntegrationInstance, TIntegrationBound extends boolean> = TIntegrationBound extends true ? Omit<TContext, "integration"> & {
    /** The owning integration bound by `definePlugin.forIntegration<T>()`. */
    readonly integration: Readonly<FarmPluginIntegrationContext<TIntegrationInstance>>;
} : TContext;
interface FarmPluginLifecycle {
    /**
     * Register a database, storage, queue, or other resource disposer.
     * Disposers run once in reverse registration order after plugin shutdown hooks.
     */
    onShutdown(dispose: () => void | Promise<void>): () => void;
}
interface FarmRequestPluginContext<TIntegrationInstance = unknown> extends FarmPluginContext<TIntegrationInstance> {
    /** Request-scoped values for the current hook invocation. */
    readonly req: FarmRequestStore;
}
interface RouteDiscoveredPayload {
    kind: "page" | "layout";
    pattern: string;
    modulePath: string;
}
interface RoutesGeneratedPayload {
    routes: RouteDiscoveredPayload[];
    pageCount: number;
    layoutCount: number;
}
interface MiddlewareDiscoveredPayload {
    path: string;
    filePath: string;
    handlerCount: number;
}
interface APIRouteDiscoveredPayload {
    path: string;
    filePath: string;
    methods: string[];
}
interface RouteMatchPayload {
    pathname: string;
    method?: string;
}
interface RouteMatchResultPayload {
    pathname: string;
    matched: boolean;
    routePattern: string | null;
    params: Record<string, string>;
    layoutPatterns: string[];
}
interface RenderLifecyclePayload {
    pathname: string;
    method: string;
    routePattern: string | null;
    params: Record<string, string>;
}
interface APIHandlerLifecyclePayload {
    pathname: string;
    method: string;
    routePath?: string;
}
interface ErrorLifecyclePayload {
    phase: string;
    error: unknown;
    meta?: Record<string, unknown>;
}
interface HMRUpdatePayload {
    file: string;
    modules: string[];
}
interface BundleLifecyclePayload {
    root: string;
    preset: string;
    universal: boolean;
    distDir: string;
    outputDir?: string;
}
interface BundleResultPayload extends BundleLifecyclePayload {
    success: boolean;
}
interface NitroBuildLifecyclePayload {
    root: string;
    preset: string;
    distDir: string;
    outputDir: string;
}
interface ShutdownPayload {
    reason: string;
}
type FarmPluginRuntimeKind = "request" | "page" | "api" | "action" | "integration" | "docs" | "asset" | (string & {});
interface FarmPluginRouteRuntimePayload {
    pathname: string;
    pattern?: string | null;
    params?: Record<string, string>;
}
interface FarmPluginSetupContext<TIntegrationInstance = unknown> extends FarmPluginContext<TIntegrationInstance> {
    env: ResolvedFarmEnv;
}
interface FarmPluginStateContext<TState = unknown, TIntegrationInstance = unknown> extends FarmPluginContext<TIntegrationInstance> {
    state: TState;
}
interface FarmPluginRuntimeBaseEvent<TState = unknown, TIntegrationInstance = unknown> extends FarmPluginStateContext<TState, TIntegrationInstance> {
    request: Request;
    /** Request-scoped values shared by plugin hooks. */
    req: FarmRequestStore;
    kind: FarmPluginRuntimeKind;
    route?: FarmPluginRouteRuntimePayload;
    signal: AbortSignal;
    waitUntil(promise: Promise<unknown>): void;
}
type FarmPluginRuntimeContextEvent<TState = unknown, TIntegrationInstance = unknown> = FarmPluginRuntimeBaseEvent<TState, TIntegrationInstance>;
interface FarmPluginRuntimeBeforeEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown> extends FarmPluginRuntimeBaseEvent<TState, TIntegrationInstance> {
    ctx: Readonly<TRequestContext>;
}
interface FarmPluginRuntimeAfterEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown> extends FarmPluginRuntimeBeforeEvent<TState, TRequestContext, TIntegrationInstance> {
    response: Response;
    durationMs: number;
}
interface FarmPluginRuntimeErrorEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown> extends FarmPluginRuntimeBeforeEvent<TState, TRequestContext, TIntegrationInstance> {
    error: unknown;
    durationMs: number;
}
type FarmPluginRuntimeStartEvent<TState = unknown, TIntegrationInstance = unknown> = FarmPluginStateContext<TState, TIntegrationInstance>;
interface FarmPluginRuntimeCloseEvent<TState = unknown, TIntegrationInstance = unknown> extends FarmPluginStateContext<TState, TIntegrationInstance>, ShutdownPayload {
}
type FarmPluginContextFor<TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmPluginContext<TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
type FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmRequestPluginContext<TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
type FarmPluginSetupContextFor<TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmPluginSetupContext<TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
type FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<FarmPluginStateContext<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>;
type FarmPluginRuntimeEventFor<TEvent, TIntegrationInstance, TIntegrationBound extends boolean> = FarmPluginHookContext<TEvent, TIntegrationInstance, TIntegrationBound>;
interface FarmPluginRuntimeHooks<TState = unknown, TRequestContext extends object = Record<string, unknown>, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
    start?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeStartEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    context?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeContextEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<TRequestContext>;
    before?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeBeforeEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<Request | Response | void>;
    after?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeAfterEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<Response | void>;
    error?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeErrorEvent<TState, TRequestContext, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    close?(event: FarmPluginRuntimeEventFor<FarmPluginRuntimeCloseEvent<TState, TIntegrationInstance>, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
}
interface FarmPluginRuntimeRequestOptions {
    kind?: FarmPluginRuntimeKind;
    route?: FarmPluginRouteRuntimePayload;
    waitUntil?: (promise: Promise<unknown>) => void;
}
type FarmPluginRuntimeRequestHandler = (request: Request) => MaybePromise$1<Response>;
interface FarmPluginRuntimeSession {
    request: Request;
    response?: Response;
    ctx: Readonly<Record<string, unknown>>;
    startedAt: number;
    options: FarmPluginRuntimeRequestOptions;
    waitUntil(promise: Promise<unknown>): void;
}
type FarmPluginDiscoveredRoute = RouteDiscoveredPayload | ({
    kind: "middleware";
} & MiddlewareDiscoveredPayload) | ({
    kind: "api";
} & APIRouteDiscoveredPayload);
interface FarmPluginRouterHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
    discovered?(route: FarmPluginDiscoveredRoute, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    generated?(routes: RoutesGeneratedPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    before?(route: RouteMatchPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    after?(result: RouteMatchResultPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
}
interface FarmPluginRenderHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
    before?(render: RenderLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    html?(html: string, render: RenderLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<string | void>;
}
interface FarmPluginBuildHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
    before?(bundle: BundleLifecyclePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    configure?(buildConfig: any, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<any>;
    after?(result: BundleResultPayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
}
interface FarmPluginDevHooks<TState = unknown, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false> {
    server?(viteServer: ViteDevServer, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
    update?(update: HMRUpdatePayload, context: FarmPluginStateContextFor<TState, TIntegrationInstance, TIntegrationBound>): MaybePromise$1<void>;
}
interface FarmPluginClientConfig<TState = unknown, TPublic = undefined> extends FarmClientPlugin<TState, TPublic> {
    /** Explicitly public, JSON-safe data embedded in the browser bundle. */
    public?: TPublic;
}
interface FarmPlugin<TState = any, TRequestContext extends object = Record<string, unknown>, TClientState = any, TClientPublic = any, TIntegrationInstance = unknown, TIntegrationBound extends boolean = false, TRoutes extends PluginRoutes = PluginRoutes> {
    name: string;
    version?: string;
    enforce?: "pre" | "post";
    /** Declarative API routes, mounted through the normal dev and production API pipeline. */
    routes?: PluginRoutesFactory<TRoutes>;
    /** Transform Farm config before the development or production pipeline is created. */
    configure?: (config: FarmConfig, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => MaybePromise$1<FarmConfig | void>;
    /** Initialize private plugin state once for this plugin manager. */
    setup?: (context: FarmPluginSetupContextFor<TIntegrationInstance, TIntegrationBound>) => MaybePromise$1<TState>;
    runtime?: FarmPluginRuntimeHooks<TState, TRequestContext, TIntegrationInstance, TIntegrationBound>;
    router?: FarmPluginRouterHooks<TState, TIntegrationInstance, TIntegrationBound>;
    render?: FarmPluginRenderHooks<TState, TIntegrationInstance, TIntegrationBound>;
    build?: FarmPluginBuildHooks<TState, TIntegrationInstance, TIntegrationBound>;
    dev?: FarmPluginDevHooks<TState, TIntegrationInstance, TIntegrationBound>;
    /** Optional browser lifecycle for this logical plugin. */
    client?: FarmPluginClientConfig<TClientState, TClientPublic>;
    /** @internal Carries the expected integration instance type without runtime data. */
    readonly [FARM_PLUGIN_INTEGRATION_INSTANCE]?: (instance: TIntegrationInstance) => void;
    /** @internal Prevents integration-bound plugins from being registered globally. */
    readonly [FARM_PLUGIN_INTEGRATION_BOUND]?: TIntegrationBound;
    /** @deprecated Use `setup` instead. */
    init?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `runtime.start` instead. */
    ready?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `dev.server` instead. */
    devServerCreated?: (viteServer: ViteDevServer, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `configure` instead. */
    config?: (config: FarmConfig, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => FarmConfig | Promise<FarmConfig>;
    configResolved?: (config: FarmConfig, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `build.before` instead. */
    buildStart?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `build.after` instead. */
    buildEnd?: (context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `router.discovered` instead. */
    routeDiscovered?: (route: RouteDiscoveredPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `router.generated` instead. */
    routesGenerated?: (routes: RoutesGeneratedPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `router.discovered` instead. */
    middlewareDiscovered?: (middleware: MiddlewareDiscoveredPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `router.discovered` instead. */
    apiRouteDiscovered?: (route: APIRouteDiscoveredPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `router.before` instead. */
    beforeRouteMatch?: (route: RouteMatchPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `router.after` instead. */
    afterRouteMatch?: (result: RouteMatchResultPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `render.before` instead. */
    beforeRender?: (render: RenderLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `render.html` instead. */
    afterRender?: (html: string, render: RenderLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => string | Promise<string> | void | Promise<void>;
    /** @deprecated Use `runtime.before` instead. */
    beforeApiHandler?: (request: Request, api: APIHandlerLifecyclePayload, context: FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound>) => Request | Promise<Request> | void | Promise<void>;
    /** @deprecated Use `runtime.after` instead. */
    afterApiHandler?: (response: Response, api: APIHandlerLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => Response | Promise<Response> | void | Promise<void>;
    onError?: (error: ErrorLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `dev.update` instead. */
    hmrUpdate?: (update: HMRUpdatePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `build.before` instead. */
    beforeBundle?: (bundle: BundleLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `build.after` instead. */
    afterBundle?: (result: BundleResultPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `build.configure` instead. */
    beforeNitroBuild?: (nitroConfig: any, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => any | Promise<any>;
    afterNitroBuild?: (payload: NitroBuildLifecyclePayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `runtime.close` instead. */
    shutdown?: (payload: ShutdownPayload, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use the Web Request based `runtime.before` hook instead. */
    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use the Web Response based `runtime.after` hook instead. */
    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmRequestPluginContextFor<TIntegrationInstance, TIntegrationBound>) => void | Promise<void>;
    /** @deprecated Use `render.html` instead. */
    transformHTML?: (html: string, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => string | Promise<string>;
    /** @deprecated Use `render.before` or `render.html` instead. */
    transformPage?: (component: any, context: FarmPluginContextFor<TIntegrationInstance, TIntegrationBound>) => any | Promise<any>;
}
declare class PluginManager {
    private plugins;
    private hookPresence;
    private runtimeHookPresence;
    private context;
    private pluginStates;
    private setupComplete;
    private initialized;
    private runtimeReady;
    private runtimeClosed;
    private runtimeStartPromise?;
    private runtimeClosePromise?;
    private runtimeShutdownHooksRunning;
    private runtimeDisposers;
    private runtimeRequestContexts;
    private failedRuntimeSessions;
    constructor(context: Omit<FarmPluginContext, "requestContext" | "lifecycle">);
    private createPluginHookContext;
    private createRequestHookContext;
    private copyRequestStore;
    private copyRuntimeRequestContext;
    private createRuntimeBaseEvent;
    private createRuntimeRequestContext;
    private runRuntimeErrorHooks;
    private createStateHookContext;
    private getPluginHooks;
    private getHookContext;
    addPlugin(plugin: FarmPlugin): void;
    addPlugins(plugins: FarmPlugin[]): void;
    getPlugins(): FarmPlugin[];
    getSortedPlugins(): FarmPlugin[];
    hasHook(hookName: keyof FarmPlugin): boolean;
    hasRuntimeHook(hookName: "context" | "before" | "after" | "error"): boolean;
    hasRuntimeRequestHooks(): boolean;
    copyRequestContext(source: FarmRequest | Request, target: FarmRequest | Request): void;
    setupPlugins(): Promise<void>;
    startRuntime(): Promise<void>;
    closeRuntime(reason?: string): Promise<void>;
    beginRuntimeRequest(request: Request, options?: FarmPluginRuntimeRequestOptions): Promise<FarmPluginRuntimeSession>;
    endRuntimeRequest(session: FarmPluginRuntimeSession, initialResponse: Response): Promise<Response>;
    failRuntimeRequest(session: FarmPluginRuntimeSession, error: unknown): Promise<void>;
    runRuntimeRequest(request: Request, handler: FarmPluginRuntimeRequestHandler, options?: FarmPluginRuntimeRequestOptions): Promise<Response>;
    runHook<K extends keyof FarmPlugin>(hookName: K, ...args: any[]): Promise<any>;
    runHookSerial<K extends keyof FarmPlugin>(hookName: K, initialValue: any, ...args: any[]): Promise<any>;
    runHookParallel<K extends keyof FarmPlugin>(hookName: K, ...args: any[]): Promise<boolean>;
    /** @internal Runs hooks for only the plugins selected by the runtime adapter. */
    runHookParallelFiltered<K extends keyof FarmPlugin>(hookName: K, include: (plugin: FarmPlugin) => boolean, ...args: any[]): Promise<boolean>;
    updateContext(updates: Partial<FarmPluginContext>): void;
}
declare function definePlugin<TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined, TIntegrationInstance = unknown, const TRoutes extends PluginRoutes = PluginRoutes>(plugin: FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, false, TRoutes>): FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, false, TRoutes>;
declare namespace definePlugin {
    /** Bind an integration instance type while preserving inference for plugin state and context. */
    function forIntegration<TIntegrationInstance>(): <TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined>(plugin: FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, true>) => FarmPlugin<TState, TRequestContext, TClientState, TClientPublic, TIntegrationInstance, true>;
}

type FarmIntegrationCategory = "auth" | "payment" | "monitoring" | "logging" | (string & {});
/** @deprecated Use FarmIntegrationCategory instead. */
type FarmIntegrationSlot = FarmIntegrationCategory;
type FarmIntegrationRouteParamValue = string | string[];
type FarmIntegrationRouteParams = Record<string, FarmIntegrationRouteParamValue>;
type FarmIntegrationRouteMethod = FarmIntegrationAPIMethod | Lowercase<FarmIntegrationAPIMethod> | "ALL" | "all";
type FarmIntegrationRouteInputSource = "body" | "query";
type MaybePromise<T> = T | Promise<T>;
type FarmIntegrationValidationPathSegment = PropertyKey | {
    readonly key: PropertyKey;
};
interface FarmIntegrationRouteInput<TBody = unknown, TQuery = unknown> {
    body?: TBody;
    query?: TQuery;
}
interface FarmIntegrationValidationIssue {
    source: FarmIntegrationRouteInputSource;
    path?: readonly (string | number)[];
    code?: string;
    message: string;
}
interface FarmIntegrationValidationErrorLike {
    issues?: readonly {
        path?: readonly FarmIntegrationValidationPathSegment[];
        code?: string;
        message?: string;
    }[];
    message?: string;
}
type FarmIntegrationValidationResult<TValue> = {
    success: true;
    data: TValue;
} | {
    success: false;
    error: FarmIntegrationValidationErrorLike;
};
type FarmIntegrationStandardValidationResult<TValue> = {
    value: TValue;
} | {
    issues: readonly {
        path?: readonly FarmIntegrationValidationPathSegment[];
        code?: string;
        message: string;
    }[];
};
interface FarmIntegrationInputSchema<TValue = unknown> {
    _output?: TValue;
    parse?(value: unknown): MaybePromise<TValue>;
    safeParse?(value: unknown): MaybePromise<FarmIntegrationValidationResult<TValue>>;
    safeParseAsync?(value: unknown): Promise<FarmIntegrationValidationResult<TValue>>;
    "~standard"?: {
        validate(value: unknown): MaybePromise<FarmIntegrationStandardValidationResult<TValue>>;
        types?: {
            output: TValue;
        };
    };
}
interface FarmIntegrationRouteInputSchemas<TBody = unknown, TQuery = unknown> {
    body?: FarmIntegrationInputSchema<TBody>;
    query?: FarmIntegrationInputSchema<TQuery>;
}
/** @deprecated Use `FarmRequestStore` and access it through `ctx.req`. */
type FarmIntegrationRequestContextStore = FarmRequestStore;
declare const FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY = "farm.integration.internalDispatch";
/**
 * Request-context key under which an integration middleware can hand
 * `Set-Cookie` values to the runtime when it returns `void` (i.e. lets the
 * request continue to the downstream route/page handler). The runtime reads
 * this key back after a `void` middleware return and forwards the cookies onto
 * the response it ultimately sends, so a server-side session refresh (or any
 * other cookie rotation) reaches the browser instead of being dropped.
 */
declare const FARM_INTEGRATION_SET_COOKIES_KEY = "farm:integration:set-cookies";
/**
 * Forward `Set-Cookie` values from an integration middleware that returns
 * `void` (the authenticated/passthrough branch) to the runtime, so they are
 * merged onto the response the runtime sends for the matched route. This is
 * the passthrough counterpart to appending `Set-Cookie` to a `Response` the
 * middleware returns directly (e.g. a failure redirect): both paths can rotate
 * auth cookies, and both must be able to reach the browser.
 */
declare function forwardIntegrationSetCookies(context: Pick<FarmIntegrationHandlerContext, "req">, cookies: string[]): void;
type FarmIntegrationRouteDb<TSchema extends FarmIntegrationSchema | undefined> = InferFarmIntegrationOrmClient<TSchema>;
interface FarmIntegrationRouteStorageArgs<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    getClient(): Promise<unknown | undefined>;
    getOrm(): Promise<FarmIntegrationRouteDb<TSchema>>;
}
interface FarmIntegrationRouteArgs<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    db: FarmIntegrationRouteDb<TSchema>;
    getDb(): Promise<FarmIntegrationRouteDb<TSchema>>;
    storage: FarmIntegrationRouteStorageArgs<TSchema>;
}
interface FarmIntegrationConfigContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    key: string;
    integration: FarmIntegration<TSchema, any>;
    appConfig: FarmPluginContext["config"];
    /** Alias for appConfig. */
    config: FarmPluginContext["config"];
    args: FarmIntegrationRouteArgs<TSchema>;
    env: Record<string, string | undefined>;
    isDev: boolean;
    isProd: boolean;
}
interface FarmIntegrationConfigDefinition<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    schema?: FarmIntegrationInputSchema<TConfig>;
    env?: Record<string, string | readonly string[]>;
    defaults?: Partial<TConfig> | ((context: FarmIntegrationConfigContext<TSchema>) => MaybePromise<Partial<TConfig>>);
    input?: Partial<TConfig> | ((context: FarmIntegrationConfigContext<TSchema>) => MaybePromise<Partial<TConfig>>);
    resolve?(context: FarmIntegrationConfigContext<TSchema>): MaybePromise<TConfig | Partial<TConfig> | undefined>;
}
type FarmIntegrationConfigInput<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationInputSchema<TConfig> | FarmIntegrationConfigDefinition<TConfig, TSchema>;
type FarmIntegrationLifecycleLogLevel = "info" | "warn" | "error";
interface FarmIntegrationLifecycleLogger {
    info(message: string, meta?: Record<string, unknown>): void;
    warn(message: string, meta?: Record<string, unknown>): void;
    error(message: string, meta?: Record<string, unknown>): void;
}
interface FarmIntegrationLifecycleContext<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationConfigContext<TSchema> {
    integration: FarmIntegration<TSchema, TConfig>;
    integrationConfig: TConfig;
    log: FarmIntegrationLifecycleLogger;
    reason?: string;
    cleanup(callback?: () => MaybePromise<void>): Promise<void>;
}
type FarmIntegrationLifecycleHook<TConfig = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationLifecycleContext<TConfig, TSchema>) => MaybePromise<void>;
/**
 * Small per-call integration metadata. Values received over HTTP are
 * client-controlled and should be validated before authorization decisions.
 */
type FarmIntegrationData = Record<string, unknown>;
interface FarmIntegrationHandlerContext<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    request: Request;
    requestId: string;
    url: URL;
    pathname: string;
    method: string;
    params: FarmIntegrationRouteParams;
    input: FarmIntegrationRouteInput<TBody, TQuery>;
    args: FarmIntegrationRouteArgs<TSchema>;
    data: FarmIntegrationData;
    integration: {
        category: FarmIntegrationCategory;
        /** @deprecated Use category instead. */
        slot: FarmIntegrationCategory;
        type: string;
        instance: unknown;
    };
    route: {
        kind: "route" | "middleware";
        path: string;
        methods: readonly string[];
    };
    req: FarmRequestStore;
    /** @deprecated Use `req` instead. */
    requestContext: FarmRequestStore;
    config: FarmPluginContext["config"];
    isDev: boolean;
    isProd: boolean;
}
interface FarmIntegrationRouteHookContext<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationHandlerContext<TBody, TQuery, TSchema> {
    response?: Response;
}
type FarmIntegrationRouteHook<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = {
    bivarianceHack(request: Request, context: FarmIntegrationRouteHookContext<TBody, TQuery, TSchema>): Promise<Response | void> | Response | void;
}["bivarianceHack"];
interface FarmIntegrationRoute<TBody = unknown, TQuery = unknown, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    path: string;
    method?: FarmIntegrationRouteMethod;
    methods?: readonly FarmIntegrationRouteMethod[];
    middleware?: readonly FarmIntegrationRouteMiddleware<TSchema>[];
    before?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
    after?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
    rawBody?: boolean;
    bodyFormat?: FarmIntegrationAPIBodyFormat;
    body?: FarmIntegrationInputSchema<TBody>;
    query?: FarmIntegrationInputSchema<TQuery>;
    input?: FarmIntegrationRouteInputSchemas<TBody, TQuery>;
    handler(request: Request, context: FarmIntegrationHandlerContext<TBody, TQuery, TSchema>): Promise<Response> | Response;
}
interface FarmTypedIntegrationRoute<TPath extends string = string, TBody = never, TQuery = never, TResponse = unknown, TServer extends boolean = false, TMethod extends FarmIntegrationAPIMethod = FarmIntegrationAPIMethod, TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationRoute<TBody, TQuery, TSchema> {
    path: TPath;
    method: TMethod;
    __operation: FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, TMethod>;
}
interface FarmIntegrationRouteMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
}
interface FarmIntegrationMiddleware<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    matcher?: string | string[];
    handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, TSchema>): Promise<Response | void> | Response | void;
}
interface FarmIntegrationProviderProps {
    children: ReactNode;
}
interface FarmIntegrationProviderComponentReference {
    /** Client-safe module specifier using `@/`, a path relative to the app root, or a package. */
    module: string;
    /** Named export to use. Defaults to the module's default export. */
    export?: string;
}
interface FarmIntegrationProvider {
    name: string;
    type: string;
    props?: Record<string, unknown>;
    /**
     * The provider can be instantiated independently around each isolated
     * client root without relying on context or state owned by the route root.
     * Providers are treated as route-wide unless they explicitly opt in.
     */
    supportsIsolatedHydration?: boolean;
    component?: ComponentType<FarmIntegrationProviderProps> | FarmIntegrationProviderComponentReference;
}
interface FarmIntegrationDocumentNavigation {
    matcher: string | readonly string[];
}
/** @deprecated Use `FarmSchemaFieldType`. */
type FarmIntegrationSchemaFieldType = FarmSchemaFieldType;
/** @deprecated Use `FarmSchemaReference`. */
type FarmIntegrationSchemaReference = FarmSchemaReference;
/** @deprecated Use `FarmSchemaField`. */
type FarmIntegrationSchemaField = FarmSchemaField;
/** @deprecated Use `FarmSchemaConstraint`. */
type FarmIntegrationSchemaConstraint = FarmSchemaConstraint;
/** @deprecated Use `FarmSchemaModel`. */
type FarmIntegrationSchemaModel = FarmSchemaModel;
/** @deprecated Use `FarmSchemaModelExtension`. */
type FarmIntegrationSchemaModelExtension = FarmSchemaModelExtension;
/** @deprecated Use `FarmSchemaModelOverride`. */
type FarmIntegrationSchemaModelOverride = FarmSchemaModelOverride;
/** @deprecated Use `FarmSchema`. */
type FarmIntegrationSchema = FarmSchema;
/** @deprecated Use `defineSchema`. This is an exact alias, not a wrapper. */
declare const defineIntegrationSchema: typeof defineSchema;
type FarmIntegrationLogPhase = "registered" | "validate" | "setup" | "ready" | "dispose" | "request:start" | "request:end" | "request:error";
interface FarmIntegrationLogEvent {
    category: FarmIntegrationCategory;
    /** @deprecated Use category instead. */
    slot: FarmIntegrationCategory;
    type: string;
    phase: FarmIntegrationLogPhase;
    route?: {
        kind: "route" | "middleware";
        path: string;
        methods: readonly string[];
    };
    requestId?: string;
    request?: Request;
    response?: Response;
    error?: unknown;
    durationMs?: number;
    level?: FarmIntegrationLifecycleLogLevel;
    message?: string;
    meta?: Record<string, unknown>;
    context: Map<string, unknown>;
}
type FarmIntegrationLogger = (event: FarmIntegrationLogEvent) => void | Promise<void>;
interface FarmIntegrationPluginOwner {
    key: string;
    category: FarmIntegrationCategory;
    type: string;
    source: "lifecycle" | "contribution";
    serverRuntime: boolean;
}
/** A normal plugin or an integration-bound plugin compatible with the shared instance. */
type FarmIntegrationContributedPlugin<TInstance = unknown> = FarmPlugin<any, any, any, any, unknown, false> | FarmPlugin<any, any, any, any, TInstance, true>;
interface FarmIntegration<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined, TConfig = unknown, TInstance = unknown> {
    readonly kind: "farm-integration";
    category: FarmIntegrationCategory;
    /** @deprecated Use category instead. */
    slot?: FarmIntegrationCategory;
    type: string;
    instance: TInstance;
    /** Set to false when a platform adapter owns this integration's production routes. */
    serverRuntime?: boolean;
    api?: FarmIntegrationAPI;
    schema?: TSchema;
    config?: FarmIntegrationConfigInput<TConfig, TSchema>;
    validate?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
    setup?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
    ready?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
    dispose?: FarmIntegrationLifecycleHook<TConfig, TSchema>;
    log?: FarmIntegrationLogger;
    routes?: readonly FarmIntegrationRoute<any, any, TSchema>[];
    endpoints?: FarmIntegrationEndpoints<TSchema>;
    middleware?: readonly FarmIntegrationMiddleware<TSchema>[];
    providers?: readonly FarmIntegrationProvider[];
    documentNavigations?: readonly FarmIntegrationDocumentNavigation[];
    /** Additional Farm plugins owned and configured by this integration. */
    plugins?: readonly FarmIntegrationContributedPlugin<NoInfer<TInstance>>[];
}
type FarmIntegrationsUserConfig = Record<string, FarmIntegration<any, any, any> | undefined>;
/** @internal Identifies plugins owned by platform-managed integrations. */
declare function getFarmIntegrationPluginServerRuntime(plugin: FarmPlugin): boolean | undefined;
/** Returns the integration that contributed a normalized plugin, when applicable. */
declare function getFarmIntegrationPluginOwner(plugin: FarmPlugin): Readonly<FarmIntegrationPluginOwner> | undefined;
type IntegrationRouteBuilderOptions<TBody, TQuery, TServer extends boolean, TSchema extends FarmIntegrationSchema | undefined> = {
    middleware?: readonly FarmIntegrationRouteMiddleware<TSchema>[];
    before?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
    after?: readonly FarmIntegrationRouteHook<TBody, TQuery, TSchema>[];
    rawBody?: boolean;
    headers?: Record<string, string>;
    credentials?: RequestCredentials;
    bodyFormat?: FarmIntegrationAPIBodyFormat;
    responseFormat?: FarmIntegrationAPIResponseFormat;
    isServer?: TServer;
    body?: FarmIntegrationInputSchema<TBody>;
    query?: FarmIntegrationInputSchema<TQuery>;
    input?: FarmIntegrationRouteInputSchemas<TBody, TQuery>;
    handler(request: Request, context: FarmIntegrationHandlerContext<TBody, TQuery, TSchema>): Promise<Response> | Response;
};
interface FarmIntegrationRouteFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    get<TPath extends string, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: Omit<IntegrationRouteBuilderOptions<never, TQuery, TServer, TSchema>, "bodyFormat">): FarmTypedIntegrationRoute<TPath, never, TQuery, TResponse, TServer, "GET", TSchema>;
    post<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "POST", TSchema>;
    query<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "QUERY", TSchema>;
    put<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "PUT", TSchema>;
    patch<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "PATCH", TSchema>;
    delete<TPath extends string, TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: IntegrationRouteBuilderOptions<TBody, TQuery, TServer, TSchema>): FarmTypedIntegrationRoute<TPath, TBody, TQuery, TResponse, TServer, "DELETE", TSchema>;
    options<TPath extends string, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: Omit<IntegrationRouteBuilderOptions<never, TQuery, TServer, TSchema>, "bodyFormat">): FarmTypedIntegrationRoute<TPath, never, TQuery, TResponse, TServer, "OPTIONS", TSchema>;
    head<TPath extends string, TResponse = unknown, TQuery = never, TServer extends boolean = false>(path: TPath, input: Omit<IntegrationRouteBuilderOptions<never, TQuery, TServer, TSchema>, "bodyFormat">): FarmTypedIntegrationRoute<TPath, never, TQuery, TResponse, TServer, "HEAD", TSchema>;
}
interface FarmIntegrationRoutesFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> {
    route: FarmIntegrationRouteFactory<TSchema>;
    integrationRoute: FarmIntegrationRouteFactory<TSchema>;
}
type FarmIntegrationRoutesFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationRoutesFactoryContext<TSchema>) => readonly FarmIntegrationRoute<any, any, TSchema>[];
type FarmIntegrationEndpointValue<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationRoute<any, any, TSchema> | readonly FarmIntegrationEndpointValue<TSchema>[] | {
    readonly [key: string]: FarmIntegrationEndpointValue<TSchema> | undefined;
};
type FarmIntegrationEndpoints<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = {
    readonly [key: string]: FarmIntegrationEndpointValue<TSchema> | undefined;
};
interface FarmIntegrationEndpointsFactoryContext<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> extends FarmIntegrationRoutesFactoryContext<TSchema> {
    endpoint: FarmIntegrationRouteFactory<TSchema>;
}
type FarmIntegrationEndpointsFactory<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = (context: FarmIntegrationEndpointsFactoryContext<TSchema>) => FarmIntegrationEndpoints<TSchema>;
declare function createIntegrationRoute<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined>(_schema?: TSchema): FarmIntegrationRouteFactory<TSchema>;
declare const integrationRoute: FarmIntegrationRouteFactory<undefined>;
type RegisteredIntegrationRuntime = {
    integration: FarmIntegration;
    config: FarmPluginContext["config"];
    isDev: boolean;
    isProd: boolean;
};
type FarmIntegrationRoutesInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = readonly FarmIntegrationRoute<any, any, TSchema>[] | FarmIntegrationRoutesFactory<TSchema>;
type FarmIntegrationEndpointsInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined> = FarmIntegrationEndpoints<TSchema> | FarmIntegrationEndpointsFactory<TSchema>;
type FarmIntegrationInput<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined, TConfig = unknown, TInstance = unknown> = Omit<FarmIntegration<TSchema, TConfig, TInstance>, "kind" | "category" | "slot" | "instance" | "config" | "routes" | "endpoints" | "plugins"> & {
    instance: TInstance;
    config?: FarmIntegrationConfigInput<TConfig, TSchema>;
    routes?: FarmIntegrationRoutesInput<TSchema>;
    endpoints?: FarmIntegrationEndpointsInput<TSchema>;
    plugins?: readonly FarmIntegrationContributedPlugin<NoInfer<TInstance>>[];
} & ({
    category: FarmIntegrationCategory;
    slot?: FarmIntegrationCategory;
} | {
    category?: FarmIntegrationCategory;
    slot: FarmIntegrationCategory;
});
type FarmIntegrationCategoryInput = {
    category: FarmIntegrationCategory;
    slot?: FarmIntegrationCategory;
} | {
    category?: FarmIntegrationCategory;
    slot: FarmIntegrationCategory;
};
type FarmIntegrationShapeForInference = FarmIntegrationCategoryInput & {
    api?: FarmIntegrationAPI;
    schema?: FarmIntegrationSchema;
    config?: unknown;
    routes?: unknown;
    endpoints?: unknown;
};
type ExtractIntegrationSchema<TIntegration> = TIntegration extends {
    schema: infer TSchema extends FarmIntegrationSchema;
} ? TSchema : undefined;
type ResolveIntegrationRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = TRoutes extends FarmIntegrationRoutesFactory<TSchema> ? ReturnType<TRoutes> : TRoutes;
type ResolveIntegrationEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = TEndpoints extends FarmIntegrationEndpointsFactory<TSchema> ? ReturnType<TEndpoints> : TEndpoints;
type ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema extends FarmIntegrationSchema | undefined> = ResolveIntegrationRoutesInput<TRoutes, TSchema> extends readonly (infer TRoute)[] ? TRoute : never;
type ExtractIntegrationRoutesFromEndpointValue<TValue> = TValue extends FarmIntegrationRouteOperationCarrier<string, any> ? TValue : TValue extends readonly (infer TItem)[] ? ExtractIntegrationRoutesFromEndpointValue<TItem> : TValue extends object ? ExtractIntegrationRoutesFromEndpointValue<TValue[keyof TValue]> : never;
type ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema extends FarmIntegrationSchema | undefined> = ExtractIntegrationRoutesFromEndpointValue<ResolveIntegrationEndpointsInput<TEndpoints, TSchema>>;
type ExtractIntegrationRouteUnion<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = (TIntegration extends {
    routes: infer TRoutes;
} ? ExtractIntegrationRoutesFromRoutesInput<TRoutes, TSchema> : never) | (TIntegration extends {
    endpoints: infer TEndpoints;
} ? ExtractIntegrationRoutesFromEndpointsInput<TEndpoints, TSchema> : never);
type ExtractDefinedIntegrationRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = [ExtractIntegrationRouteUnion<TIntegration, TSchema>] extends [never] ? undefined : readonly ExtractIntegrationRouteUnion<TIntegration, TSchema>[];
type ExtractDefinedIntegrationEndpoints<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = TIntegration extends {
    endpoints: infer TEndpoints;
} ? ResolveIntegrationEndpointsInput<TEndpoints, TSchema> : undefined;
type ExtractIntegrationAPIRoutes<TIntegration, TSchema extends FarmIntegrationSchema | undefined> = Extract<ExtractIntegrationRouteUnion<TIntegration, TSchema>, FarmIntegrationRouteOperationCarrier<string, any>>;
type ExtractIntegrationCategory<TIntegration extends FarmIntegrationCategoryInput> = TIntegration extends {
    category: infer TCategory extends FarmIntegrationCategory;
} ? TCategory : TIntegration extends {
    slot: infer TSlot extends FarmIntegrationCategory;
} ? TSlot : FarmIntegrationCategory;
type ExtractDerivedIntegrationAPI<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = TIntegration extends {
    api: infer TAPI extends FarmIntegrationAPI;
} ? TAPI : [ExtractIntegrationAPIRoutes<TIntegration, TSchema>] extends [never] ? FarmIntegrationAPI | undefined : InferIntegrationAPIFromRoutes<readonly ExtractIntegrationAPIRoutes<TIntegration, TSchema>[]>;
type DefinedIntegration<TIntegration extends FarmIntegrationShapeForInference, TSchema extends FarmIntegrationSchema | undefined = ExtractIntegrationSchema<TIntegration>> = Omit<TIntegration, "kind" | "category" | "slot" | "api" | "routes" | "endpoints"> & {
    readonly kind: "farm-integration";
    category: ExtractIntegrationCategory<TIntegration>;
    slot: ExtractIntegrationCategory<TIntegration>;
    routes: ExtractDefinedIntegrationRoutes<TIntegration, TSchema>;
    endpoints: ExtractDefinedIntegrationEndpoints<TIntegration, TSchema>;
    api: ExtractDerivedIntegrationAPI<TIntegration, TSchema>;
};
declare function defineIntegration<const TSchema extends FarmIntegrationSchema | undefined, const TConfig, TIntegration extends FarmIntegrationInput<TSchema, TConfig, any>>(integration: TIntegration & FarmIntegrationInput<TSchema, TConfig, NoInfer<TIntegration["instance"]>>): DefinedIntegration<TIntegration, TSchema>;
declare function isFarmIntegration(value: unknown): value is FarmIntegration;
declare function resolveIntegrationPlugins(integrations: FarmIntegrationsUserConfig | undefined): FarmPlugin[];
declare function getIntegrationProviders(integrations: FarmIntegrationsUserConfig | undefined): FarmIntegrationProvider[];
declare function isFarmIntegrationProviderComponentReference(value: FarmIntegrationProvider["component"]): value is FarmIntegrationProviderComponentReference;
declare function getIntegrationDocumentNavigationMatchers(integrations: FarmIntegrationsUserConfig | undefined): string[];
declare function getIntegrationSchemas(integrations: FarmIntegrationsUserConfig | undefined): Record<string, FarmIntegrationSchema>;
declare function getRegisteredIntegrationRuntime(key: string): RegisteredIntegrationRuntime | undefined;
declare function getRegisteredIntegrations(): Record<string, FarmIntegration>;
declare function getRegisteredIntegrationSchemas(): Record<string, FarmIntegrationSchema>;
declare function matchIntegrationRoute(integrations: FarmIntegrationsUserConfig | undefined, input: {
    pathname: string;
    method?: string;
}): {
    key: string;
    integration: FarmIntegration;
    route: {
        path: string;
        methods: readonly string[];
    };
    params: FarmIntegrationRouteParams;
} | null;
declare function matchRegisteredIntegrationRoute(input: {
    pathname: string;
    method?: string;
}): {
    key: string;
    integration: FarmIntegration;
    route: {
        path: string;
        methods: readonly string[];
    };
    params: FarmIntegrationRouteParams;
} | null;
declare function getRegisteredIntegrationAPIManifest(): Record<string, FarmIntegrationAPI>;
declare function dispatchIntegrationRequest(runtime: RegisteredIntegrationRuntime, request: Request, options?: {
    currentRequest?: Request;
    data?: FarmIntegrationData;
    internal?: boolean;
}): Promise<Response | null>;

declare global {
    namespace FarmJS {
        /** @internal Application route patterns registered by generated types. */
        interface RouteRegistry {
        }
    }
}
/** A renderer-neutral component accepted by Farm's file-system router. */
type FarmComponentType<TProps = Record<string, unknown>> = ((props: TProps) => any) | (new (props: TProps) => any);
/** All generated route module patterns for the current application. */
type AppRoutePattern = FarmJS.RouteRegistry extends {
    pattern: infer TPattern extends string;
} ? TPattern : string;
type FarmRoutePropsDefault = never;
type FarmRoutePropsTarget = AppRoutePattern;
type StripPageRouteSuffix<TRoute extends string> = TRoute extends `${infer TPath}?${string}` ? StripPageRouteSuffix<TPath> : TRoute extends `${infer TPath}#${string}` ? StripPageRouteSuffix<TPath> : TRoute;
type SimplifyPageRouteParams<TValue> = {
    [TKey in keyof TValue]: TValue[TKey];
} & {};
type PageRouteSegmentParams<TSegment extends string> = TSegment extends `[[...${infer TParam}]]` ? {
    [TKey in TParam]?: string;
} : TSegment extends `[...${infer TParam}]` ? {
    [TKey in TParam]: string;
} : TSegment extends `[${infer TParam}]` ? {
    [TKey in TParam]: string;
} : {};
type ExtractPageRouteParams<TRoute extends string> = TRoute extends `${infer TSegment}/${infer TRest}` ? PageRouteSegmentParams<TSegment> & ExtractPageRouteParams<TRest> : PageRouteSegmentParams<TRoute>;
/** Infer the decoded params received by a page from a route pattern. */
type PageRouteParams<TRoute extends string> = string extends TRoute ? Record<string, string> : TRoute extends string ? SimplifyPageRouteParams<ExtractPageRouteParams<StripPageRouteSuffix<TRoute>>> : never;
type ResolvePageRouteParams<TRoute extends FarmRoutePropsTarget> = [TRoute] extends [never] ? Record<string, string> : TRoute extends string ? PageRouteParams<TRoute> : Record<string, string>;
type NitroPreset = "node-server" | "vercel" | "cloudflare" | "cloudflare-pages" | "netlify" | "netlify-edge" | "bun" | "deno" | "azure" | "aws-lambda" | "firebase" | "custom" | "self-host" | "farm" | string;
type FarmMigrationCommand = string | {
    /** Shell command to run for this migration step. */
    command: string;
    /** Optional label printed by the CLI before running the command. */
    name?: string;
    /** Working directory for this command, relative to the project root unless absolute. */
    cwd?: string;
    /** Additional environment variables for this command. */
    env?: Record<string, string | undefined>;
    /** Skip this command without removing it from config. */
    skip?: boolean;
};
interface FarmMigrationsConfig {
    /** One-shot commands that create or update app/integration schemas. */
    commands?: FarmMigrationCommand[];
}
type FarmMigrationsUserConfig = FarmMigrationsConfig | FarmMigrationCommand[];
interface ResolvedFarmMigrationsConfig {
    commands: FarmMigrationCommand[];
}
interface FarmContextFactoryInput {
    request: Request;
    rawRequest?: FarmRequest;
    params: Record<string, string>;
    search: Record<string, string | string[] | undefined>;
    path: string;
}
type FarmContextFactory<TContext = unknown> = (input: FarmContextFactoryInput) => TContext | Promise<TContext>;
interface FarmAppContext {
}
interface FarmConfig {
    root?: string;
    /** App source directory. @default "src" */
    srcDir?: string;
    extends?: readonly FarmLayerEntry[];
    /** Resolved layer graph. Populated by config resolution. */
    layers?: readonly ResolvedFarmLayer[];
    outDir?: string;
    basePath?: string;
    /** Generate and canonicalize non-root application page URLs with a trailing slash. */
    trailingSlash?: boolean;
    /**
     * Component renderer used for JSX compilation, SSR, and browser hydration.
     * React is used when omitted.
     */
    renderer?: FarmRenderer;
    preset?: NitroPreset;
    deploy?: {
        target?: "vercel" | "cloudflare" | "netlify" | "node" | string;
        preset?: NitroPreset;
        outputDir?: string;
        output?: string;
        projectName?: string;
        vercel?: {
            outputDirectory?: string;
            buildCommand?: string;
            installCommand?: string;
            framework?: string | null;
        };
        cloudflare?: {
            outputDir?: string;
            projectName?: string;
        };
        netlify?: {
            outputDir?: string;
            site?: string;
        };
    };
    storage?: FarmStorageUserConfig;
    /** Shared application data, route, ISR, and PPR cache. */
    cache?: FarmCacheUserConfig;
    integrations?: FarmIntegrationsUserConfig;
    /** Farm-native authentication. `true` enables email/password auth. */
    auth?: FarmAuthUserConfig | ResolvedFarmAuthConfig;
    plugins?: FarmPlugin[];
    migrations?: FarmMigrationsUserConfig;
    /** Map portable cron schedules to ordinary GET API routes. */
    cron?: FarmCronUserConfig | FarmCronResolvedConfig | false;
    workflows?: FarmWorkflowsUserConfig | boolean;
    /** Public base URL and path used by Farm's browser API clients. */
    api?: FarmAPIConfig;
    env?: FarmEnvConfig<any, any> | ResolvedFarmEnv;
    middleware?: FarmMiddlewareConfig;
    routeRules?: FarmRouteRules;
    context?: FarmContextFactory<any>;
    /** Server ingress and trusted-proxy policy. */
    server?: FarmServerConfig;
    serverActions?: FarmServerActionsConfig;
    /** App-wide HTTP security policy. */
    security?: FarmSecurityConfig | ResolvedFarmSecurityConfig;
    /** Opt-in agent-readiness primitives (JSON-LD and related). Off by default. */
    agent?: FarmAgentUserConfig;
    images?: FarmImageConfig;
    /** Browser resource scheduling and preload budgets. */
    performance?: FarmPerformanceConfig;
    /** Built-in light, dark, and system color-mode runtime. */
    theme?: FarmThemeConfig | ResolvedFarmThemeConfig | false;
    i18n?: FarmI18nUserConfig | ResolvedFarmI18nConfig | false;
    /** Build identifier used to detect stale clients during rolling deployments. */
    deploymentId?: string;
    /** Optional project-relative module used for unmatched page routes. */
    notFound?: {
        component?: string;
    };
    /** Server-only application runtime values. */
    serverRuntimeConfig?: Record<string, unknown>;
    /** Serializable application values exposed to `src/client.ts`. */
    publicRuntimeConfig?: Record<string, unknown>;
    docs?: FarmDocsUserConfig | FarmDocsResolvedConfig;
    md?: FarmMarkdownUserConfig | FarmMarkdownResolvedConfig | boolean;
    mdx?: FarmMdxUserConfig | FarmMdxResolvedConfig;
    observability?: FarmObservabilityUserConfig;
    /** Farm product telemetry for deployed server runtimes. Set to false to disable. */
    telemetry?: boolean;
    /**
     * Development-only runtime inspector. Enabled by default during `farm dev`.
     *
     * @deprecated The built-in dashboard is deprecated. Install `@farm.js/devtools` and add
     * `devtools()` to `plugins` instead; it reuses this runtime and owns the maintained UI.
     * `devtools: false` and `shortcut` remain supported for the transition.
     */
    devtools?: FarmDevtoolsUserConfig;
    /** Development-only browser feedback for build and HMR activity. */
    devIndicators?: FarmDevIndicatorsConfig;
    /**
     * When true, Link href is not strictly typed (accepts any string).
     * Use when you want to skip route-type errors on Link or don't use generated route types.
     */
    suppressLintOnLink?: boolean;
    experimental?: {
        serverComponents?: boolean;
        serverActions?: boolean;
        /**
         * Enables Partial Prerendering (static-shell caching). Routes still opt in
         * individually with `export const ppr = true`, the Next-compatible
         * `export const experimental_ppr = true`, or a `"use ppr"` directive;
         * without this flag those declarations are inert and the route renders
         * fully dynamically.
         *
         * @experimental
         * @default false
         */
        ppr?: boolean;
        /**
         * Controls non-RSC hydration ownership for server modules that import
         * leaf `"use client"` components.
         *
         * - `"off"` keeps the current route-wide hydration boundary.
         * - `"analyze"` reports eligible boundaries without changing runtime behavior.
         * - `"enabled"` hydrates eligible client leaves independently and falls
         *   back to route-wide hydration for unsupported module graphs.
         *
         * This does not enable React Server Components. `"use client"` remains a
         * valid client-boundary declaration in normal SSR applications.
         *
         * @experimental
         * @default "off"
         */
        isolatedClientHydration?: FarmIsolatedClientHydrationMode;
        /**
         * Automatically optimize eligible server-only host-element subtrees with
         * the native Strata renderer. Unsupported trees keep normal React
         * rendering; no application boundary component is required.
         *
         * @experimental
         * @default false
         */
        optimizedBoundary?: boolean;
    };
    vite?: any;
}
type FarmIsolatedClientHydrationMode = "off" | "analyze" | "enabled";
/**
 * Middleware data available in page components
 */
interface MiddlewareProps {
    /**
     * Map containing all data set by middleware via ctx.data.set()
     *
     * @example
     * ```tsx
     * // In middleware.ts
     * ctx.data.set('user', { id: 1, name: 'John' });
     *
     * // In page.tsx
     * const user = props.middleware?.data.get('user');
     * ```
     */
    data: Map<string, any>;
}
/**
 * Plugin context data available in server page components.
 * Only values explicitly exposed by plugins are included.
 */
interface PluginContextProps {
    data: Map<string, any>;
}
/**
 * Page component props
 *
 * @param params - Dynamic route parameters (e.g., { id: '123' } for /users/[id])
 * @param searchParams - URL search/query parameters
 * @param path - Current pathname
 * @param middleware - Data set by middleware.ts (optional, available if middleware exists)
 * @param context - Data explicitly exposed by plugins for this request (optional)
 */
interface PageProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
    params: ResolvePageRouteParams<TRoute>;
    searchParams: Promise<Record<string, string | string[] | undefined>>;
    path: string;
    /**
     * Data from middleware.ts in the same directory or parent directories
     * Access data via props.middleware?.data.get('key')
     *
     * @example
     * ```tsx
     * export default function Page(props: PageProps) {
     *   const user = props.middleware?.data.get('user');
     *   const stats = props.middleware?.data.get('dashboardStats');
     *
     *   return <div>Welcome {user?.name}</div>;
     * }
     * ```
     */
    middleware?: MiddlewareProps;
    /**
     * Request-scoped plugin context values explicitly exposed by plugins.
     * Access data via props.context?.data.get('key').
     */
    context?: PluginContextProps;
}
interface LoadingProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
    params: ResolvePageRouteParams<TRoute>;
    searchParams: Promise<Record<string, string | string[] | undefined>>;
    search?: Record<string, string | string[] | undefined>;
    path: string;
    middleware?: MiddlewareProps;
    context?: PluginContextProps;
}
interface ErrorProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> extends LoadingProps<TRoute> {
    error: unknown;
    reset: () => void;
}
/**
 * Helper type to create typed page props with specific middleware data shape
 *
 * @example
 * ```tsx
 * interface MyMiddlewareData {
 *   user: { id: number; name: string };
 *   stats: { views: number };
 * }
 *
 * type MyPageProps = PagePropsWithMiddleware<MyMiddlewareData>;
 *
 * export default function Page(props: MyPageProps) {
 *   const user = props.middleware?.data.get('user');  // Fully typed!
 *   const stats = props.middleware?.data.get('stats');  // Fully typed!
 *
 *   return <div>Welcome {user?.name}</div>;
 * }
 * ```
 */
type PagePropsWithMiddleware<T extends Record<string, any>, TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = PageProps<TRoute> & {
    middleware: {
        data: Map<keyof T, T[keyof T]>;
    };
};
interface LayoutProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
    children: any;
    params: ResolvePageRouteParams<TRoute>;
}
/** Props passed to a route's `generateMetadata` function. */
type MetadataProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = PageProps<TRoute>;
/** Props passed to a layout's `generateMetadata` function. */
interface LayoutMetadataProps<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
    params: ResolvePageRouteParams<TRoute>;
}
type Page<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = FarmComponentType<PageProps<TRoute>>;
type Layout<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = FarmComponentType<LayoutProps<TRoute>>;
type Loading<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = FarmComponentType<LoadingProps<TRoute>>;
type ErrorBoundary<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = FarmComponentType<ErrorProps<TRoute>>;
/**
 * Route module exports for pages
 *
 * SSR is the default - pages render on each request
 * SSG is opt-in via `export const ssg = true`, Next-compatible route
 * config exports, or a top-of-file rendering directive.
 *
 * @example SSR Page (default):
 * ```tsx
 * export default async function Page() {
 *   const data = await fetchData();
 *   return <div>{data.title}</div>;
 * }
 * ```
 *
 * @example SSG Page:
 * ```tsx
 * export const ssg = true;
 *
 * export default function AboutPage() {
 *   return <h1>About Us</h1>;
 * }
 * ```
 *
 * @example SSG with Revalidation (ISR):
 * ```tsx
 * export const ssg = true;
 * export const revalidate = 60; // Regenerate every 60 seconds
 *
 * export default async function ProductsPage() {
 *   const products = await fetchProducts();
 *   return <ProductList products={products} />;
 * }
 * ```
 *
 * @example Dynamic SSG Route:
 * ```tsx
 * export const ssg = true;
 *
 * export async function getStaticPaths() {
 *   const posts = await fetchPosts();
 *   return posts.map(post => ({ slug: post.slug }));
 * }
 *
 * export default async function BlogPost({ params }) {
 *   const post = await fetchPost(params.slug);
 *   return <article>{post.title}</article>;
 * }
 * ```
 *
 * @example Next-compatible Route Config:
 * ```tsx
 * export const dynamic = "force-static";
 * export const revalidate = 60;
 *
 * export default function DocsPage() {
 *   return <h1>Docs</h1>;
 * }
 * ```
 *
 * @example Directive Route Config:
 * ```tsx
 * "use ssg; 60";
 *
 * export default function DocsPage() {
 *   return <h1>Docs</h1>;
 * }
 * ```
 */
interface RouteModule<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
    default?: Page<TRoute>;
    /** Execution runtime for this route. Layout values are inherited unless overridden. */
    runtime?: FarmRouteRuntime;
    /** Provider-specific execution regions, or "auto" to clear an inherited value. */
    regions?: FarmRouteRegions;
    /** Maximum execution time in seconds, or "auto" to use the provider default. */
    maxDuration?: FarmRouteMaxDuration;
    /**
     * Mark this page for Static Site Generation (SSG)
     * When true, the page will be pre-rendered at build time
     */
    ssg?: boolean;
    /**
     * Revalidate interval in seconds for Incremental Static Regeneration (ISR)
     * Only applicable when ssg = true
     */
    revalidate?: number | false;
    /**
     * Next.js-compatible rendering mode.
     * - force-static/error: pre-render at build time
     * - force-dynamic: render on each request
     */
    dynamic?: "auto" | "force-static" | "force-dynamic" | "error";
    /**
     * Opt into Partial Prerendering/static-shell caching for this route.
     * Compatible with Farm's `ppr` export and Next.js `experimental_ppr`.
     * Requires `experimental.ppr` in `farm.config.ts`; inert without it.
     */
    ppr?: boolean;
    experimental_ppr?: boolean;
    /**
     * Return all paths to pre-render for dynamic SSG routes
     * Required for dynamic routes (e.g., [slug]) when ssg = true
     */
    getStaticPaths?: GenerateStaticParams<TRoute>;
    /**
     * @deprecated Use getStaticPaths instead
     */
    generateStaticParams?: GenerateStaticParams<TRoute>;
    metadata?: Metadata & Record<string, any>;
    generateMetadata?: (props: MetadataProps<TRoute>) => Promise<Metadata> | Metadata;
}
/** A value accepted for one static route parameter. */
type StaticPathPrimitive = string | number | boolean;
/**
 * Parameters returned by `getStaticPaths` or `generateStaticParams`.
 * Arrays create individual URL segments for catch-all route parameters.
 */
type StaticPathParams = Record<string, StaticPathPrimitive | readonly StaticPathPrimitive[]>;
type StaticRouteSegmentParams<TSegment extends string> = TSegment extends `[[...${infer TParam}]]` ? {
    [TKey in TParam]?: readonly StaticPathPrimitive[];
} : TSegment extends `[...${infer TParam}]` ? {
    [TKey in TParam]: readonly StaticPathPrimitive[];
} : TSegment extends `[${infer TParam}]` ? {
    [TKey in TParam]: StaticPathPrimitive;
} : {};
type ExtractStaticRouteParams<TRoute extends string> = TRoute extends `${infer TSegment}/${infer TRest}` ? StaticRouteSegmentParams<TSegment> & ExtractStaticRouteParams<TRest> : StaticRouteSegmentParams<TRoute>;
/** Infer the values accepted from `getStaticPaths` for a route pattern. */
type StaticRouteParams<TRoute extends string> = string extends TRoute ? StaticPathParams : TRoute extends string ? SimplifyPageRouteParams<ExtractStaticRouteParams<StripPageRouteSuffix<TRoute>>> : never;
type ResolveStaticRouteParams<TRoute extends FarmRoutePropsTarget> = [TRoute] extends [never] ? StaticPathParams : TRoute extends string ? StaticRouteParams<TRoute> : StaticPathParams;
/** A route-aware `getStaticPaths` or `generateStaticParams` function. */
type GenerateStaticParams<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = () => Array<ResolveStaticRouteParams<TRoute>> | Promise<Array<ResolveStaticRouteParams<TRoute>>>;
interface LayoutModule<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> {
    default: Layout<TRoute>;
    /** Semantic fonts inherited by framework-owned surfaces for this route. */
    fonts?: FarmLayoutFonts;
    runtime?: FarmRouteRuntime;
    regions?: FarmRouteRegions;
    maxDuration?: FarmRouteMaxDuration;
    metadata?: Metadata & Record<string, any>;
    generateMetadata?: (props: LayoutMetadataProps<TRoute>) => Promise<Metadata> | Metadata;
}
interface Metadata {
    metadataBase?: string | URL;
    title?: string | {
        default?: string;
        template?: string;
    };
    description?: string;
    keywords?: string | string[];
    author?: string;
    authors?: Array<{
        name: string;
        url?: string;
    }>;
    creator?: string;
    publisher?: string;
    robots?: string | {
        index?: boolean;
        follow?: boolean;
    };
    openGraph?: {
        title?: string;
        description?: string;
        url?: string;
        siteName?: string;
        images?: string | {
            url: string;
            width?: number;
            height?: number;
            alt?: string;
            type?: string;
        } | Array<{
            url: string;
            width?: number;
            height?: number;
            alt?: string;
            type?: string;
        }>;
        image?: string;
        type?: string;
        locale?: string;
    };
    twitter?: {
        card?: "summary" | "summary_large_image" | "app" | "player";
        site?: string;
        creator?: string;
        title?: string;
        description?: string;
        images?: string | {
            url: string;
            width?: number;
            height?: number;
            alt?: string;
            type?: string;
        } | Array<string | {
            url: string;
            width?: number;
            height?: number;
            alt?: string;
            type?: string;
        }>;
    };
    alternates?: {
        canonical?: string;
        languages?: Record<string, string>;
    };
    icons?: string | {
        icon?: string | Array<string | {
            url: string;
            sizes?: string;
            type?: string;
        }>;
        shortcut?: string | Array<string | {
            url: string;
            sizes?: string;
            type?: string;
        }>;
        apple?: string | Array<string | {
            url: string;
            sizes?: string;
            type?: string;
        }>;
    };
    manifest?: string;
}
interface FarmRequest extends IncomingMessage {
    params?: Record<string, string>;
    query?: Record<string, string | string[]>;
    body?: any;
}
interface FarmResponse extends ServerResponse {
    json: (data: any) => void;
    status: (code: number) => FarmResponse;
    redirect: (url: string, status?: number) => void;
}
type ServerAction = (...args: any[]) => Promise<any>;
interface RouteSegment {
    segment: string;
    isDynamic: boolean;
    isOptional: boolean;
    isCatchAll: boolean;
}
interface ParsedRoute {
    segments: RouteSegment[];
    filePath: string;
    type: "page" | "layout" | "loading" | "error" | "not-found";
}
interface BuildOptions {
    mode: "development" | "production";
    ssr: boolean;
    minify: boolean;
    sourcemap: boolean;
}
/**
 * Represents a page to be pre-rendered at build time (SSG)
 */
interface SSGPage {
    /** The URL path for this page */
    urlPath: string;
    /** The file path to the page module */
    filePath: string;
    /** Route parameters for dynamic routes */
    params: Record<string, string>;
    /** Revalidation interval in seconds (ISR) */
    revalidate?: number;
}
/**
 * Result of SSG page collection
 */
interface SSGCollectionResult {
    /** Pages to pre-render at build time */
    ssg: SSGPage[];
    /** Routes that will be server-rendered on each request */
    ssr: string[];
}

export { type BuildOptions as $, type AppRoutePattern as A, type BundleResultPayload as B, type FarmContextFactoryInput as C, type FarmIsolatedClientHydrationMode as D, type LoadingProps as E, type FarmRouteRuntimeConfig as F, type ErrorProps as G, type PagePropsWithMiddleware as H, type MetadataProps as I, type LayoutMetadataProps as J, type Page as K, type LayoutProps as L, type Metadata as M, type NitroPreset as N, type Layout as O, type ParsedRoute as P, type Loading as Q, type RouteSegment as R, type ErrorBoundary as S, type StaticPathPrimitive as T, type StaticPathParams as U, type StaticRouteParams as V, type GenerateStaticParams as W, type LayoutModule as X, type FarmRequest as Y, type FarmResponse as Z, type ServerAction as _, type FarmPlugin as a, type FarmPluginLifecycle as a$, type SSGPage as a0, type SSGCollectionResult as a1, type FarmLayerEntry as a2, type ResolvedFarmLayer as a3, type FarmSourceRoot as a4, type ResolveFarmLayersOptions as a5, type FarmLayerResolution as a6, resolveFarmLayers as a7, getFarmSourceRoots as a8, getFarmAppDirectories as a9, resolveConfig as aA, loadConfig as aB, resolveDeployConfig as aC, resolveMigrationsConfig as aD, resolveDeployOutputPath as aE, normalizeDeployTarget as aF, getDeployTargetForPreset as aG, getPresetForDeployTarget as aH, type FarmLayerConfig as aI, type FarmPerformanceConfig as aJ, type FarmPreloadMode as aK, type FarmPreloadUserConfig as aL, type ResolvedFarmPreloadConfig as aM, type FarmCspConfig as aN, type FarmCspDirectives as aO, type FarmCspDirectiveValue as aP, type FarmCspOptions as aQ, type FarmSecurityConfig as aR, type ResolvedFarmCspConfig as aS, type FarmAuthConfig as aT, type FarmAuthDatabaseConfig as aU, type FarmAuthEmailAndPasswordConfig as aV, type FarmAuthSessionConfig as aW, type FarmAuthUserConfig as aX, type PluginRequestContext as aY, type FarmPluginContext as aZ, type FarmPluginIntegrationContext as a_, getFarmLayerAliases as aa, createFarmConfigResolutionPlugin as ab, loadFarmConfigFile as ac, type ReadonlyMiddlewareStore as ad, type FarmMiddlewareConfig as ae, type MiddlewareModule as af, type MiddlewareConfig$1 as ag, type MiddlewareContext as ah, type FarmAgentJsonLd as ai, type ResolvedFarmRouteRuntimeConfig as aj, type ResolvedFarmAPIConfig as ak, type ResolvedFarmDevtoolsConfig as al, type ResolvedFarmDevIndicatorsConfig as am, type ResolvedFarmAuthConfig as an, type ResolvedFarmPerformanceConfig as ao, type ResolvedFarmSecurityConfig as ap, type APIRequestRuntime as aq, manageFarmDocumentPreloads as ar, manageFarmHtmlPreloads as as, manageFarmLinkHeaderPreloads as at, reportFarmPreloadWarnings as au, type OpenAPIConfig as av, type FarmAgentUserConfig as aw, definePlugin as ax, FarmRuntimeShutdownError as ay, PluginManager as az, type FarmRouteRuntime as b, forwardIntegrationSetCookies as b$, type FarmRequestPluginContext as b0, type FarmRequestStore as b1, type FarmPluginRuntimeKind as b2, type FarmPluginRouteRuntimePayload as b3, type FarmPluginSetupContext as b4, type FarmPluginStateContext as b5, type FarmPluginRuntimeBaseEvent as b6, type FarmPluginRuntimeContextEvent as b7, type FarmPluginRuntimeBeforeEvent as b8, type FarmPluginRuntimeAfterEvent as b9, type ResolvedFarmConfig as bA, type RedirectConfig as bB, type HeaderConfig as bC, type RewriteConfig as bD, type ImageConfig as bE, type I18nConfig as bF, type MiddlewareConfig as bG, type FarmDeployConfig as bH, type ResolvedFarmDeployConfig as bI, type FarmDeployTarget as bJ, type FarmIntegrationCategory as bK, type FarmIntegrationSlot as bL, type FarmIntegrationRouteParamValue as bM, type FarmIntegrationRouteParams as bN, type FarmIntegrationRouteMethod as bO, type FarmIntegrationRouteInputSource as bP, type FarmIntegrationValidationPathSegment as bQ, type FarmIntegrationRouteInput as bR, type FarmIntegrationValidationIssue as bS, type FarmIntegrationValidationErrorLike as bT, type FarmIntegrationValidationResult as bU, type FarmIntegrationStandardValidationResult as bV, type FarmIntegrationInputSchema as bW, type FarmIntegrationRouteInputSchemas as bX, type FarmIntegrationRequestContextStore as bY, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as bZ, FARM_INTEGRATION_SET_COOKIES_KEY as b_, type FarmPluginRuntimeErrorEvent as ba, type FarmPluginRuntimeStartEvent as bb, type FarmPluginRuntimeCloseEvent as bc, type FarmPluginRuntimeHooks as bd, type FarmPluginRuntimeRequestOptions as be, type FarmPluginRuntimeRequestHandler as bf, type FarmPluginRuntimeSession as bg, type FarmPluginDiscoveredRoute as bh, type FarmPluginRouterHooks as bi, type FarmPluginRenderHooks as bj, type FarmPluginBuildHooks as bk, type FarmPluginDevHooks as bl, type FarmPluginClientConfig as bm, type RouteDiscoveredPayload as bn, type RoutesGeneratedPayload as bo, type MiddlewareDiscoveredPayload as bp, type APIRouteDiscoveredPayload as bq, type RouteMatchPayload as br, type RouteMatchResultPayload as bs, type RenderLifecyclePayload as bt, type APIHandlerLifecyclePayload as bu, type ErrorLifecyclePayload as bv, type HMRUpdatePayload as bw, type BundleLifecyclePayload as bx, type NitroBuildLifecyclePayload as by, type ShutdownPayload as bz, type FarmRouteRegions as c, describeIntegrationOriginRejection as c$, type FarmIntegrationRouteDb as c0, type FarmIntegrationRouteStorageArgs as c1, type FarmIntegrationRouteArgs as c2, type FarmIntegrationConfigContext as c3, type FarmIntegrationConfigDefinition as c4, type FarmIntegrationConfigInput as c5, type FarmIntegrationLifecycleLogLevel as c6, type FarmIntegrationLifecycleLogger as c7, type FarmIntegrationLifecycleContext as c8, type FarmIntegrationLifecycleHook as c9, type FarmIntegrationsUserConfig as cA, getFarmIntegrationPluginServerRuntime as cB, getFarmIntegrationPluginOwner as cC, type FarmIntegrationRouteFactory as cD, type FarmIntegrationRoutesFactoryContext as cE, type FarmIntegrationRoutesFactory as cF, type FarmIntegrationEndpointValue as cG, type FarmIntegrationEndpoints as cH, type FarmIntegrationEndpointsFactoryContext as cI, type FarmIntegrationEndpointsFactory as cJ, createIntegrationRoute as cK, integrationRoute as cL, type DefinedIntegration as cM, defineIntegration as cN, isFarmIntegration as cO, resolveIntegrationPlugins as cP, getIntegrationProviders as cQ, isFarmIntegrationProviderComponentReference as cR, getIntegrationDocumentNavigationMatchers as cS, getIntegrationSchemas as cT, getRegisteredIntegrationRuntime as cU, getRegisteredIntegrations as cV, getRegisteredIntegrationSchemas as cW, matchIntegrationRoute as cX, matchRegisteredIntegrationRoute as cY, getRegisteredIntegrationAPIManifest as cZ, dispatchIntegrationRequest as c_, type FarmIntegrationData as ca, type FarmIntegrationHandlerContext as cb, type FarmIntegrationRouteHookContext as cc, type FarmIntegrationRouteHook as cd, type FarmIntegrationRoute as ce, type FarmTypedIntegrationRoute as cf, type FarmIntegrationRouteMiddleware as cg, type FarmIntegrationMiddleware as ch, type FarmIntegrationProviderProps as ci, type FarmIntegrationProviderComponentReference as cj, type FarmIntegrationProvider as ck, type FarmIntegrationDocumentNavigation as cl, type FarmIntegrationSchemaFieldType as cm, type FarmIntegrationSchemaReference as cn, type FarmIntegrationSchemaField as co, type FarmIntegrationSchemaConstraint as cp, type FarmIntegrationSchemaModel as cq, type FarmIntegrationSchemaModelExtension as cr, type FarmIntegrationSchemaModelOverride as cs, type FarmIntegrationSchema as ct, defineIntegrationSchema as cu, type FarmIntegrationLogPhase as cv, type FarmIntegrationLogEvent as cw, type FarmIntegrationLogger as cx, type FarmIntegrationPluginOwner as cy, type FarmIntegrationContributedPlugin as cz, type FarmRouteMaxDuration as d, FARM_DEVTOOLS_LAUNCH_PARAM as d$, resolveIntegrationAllowedOrigins as d0, validateIntegrationRequestOrigin as d1, type IntegrationOriginPolicy as d2, type IntegrationOriginRejection as d3, type IntegrationOriginResult as d4, type FarmIntegrationOrmSchema as d5, type FarmIntegrationOrmClient as d6, type InferFarmIntegrationOrmField as d7, type InferFarmIntegrationOrmFields as d8, type InferFarmIntegrationOrmSchema as d9, type RateLimitStatus as dA, type MemoryRateLimitStorageOptions as dB, type NextFunction as dC, type MiddlewareResult as dD, type FarmRouteRuleRenderMode as dE, type FarmRouteRuleRedirect as dF, type FarmRouteRuleCors as dG, type FarmRouteRule as dH, type FarmRouteRules as dI, normalizeRouteRules as dJ, routeRulesToRedirects as dK, routeRulesToHeaders as dL, routeRulesToNitroRouteRules as dM, type FarmRouteRuntimeEntryKind as dN, type FarmRouteRenderingMode as dO, type FarmRouteRuntimeManifestEntry as dP, type FarmRouteRuntimeManifest as dQ, normalizeFarmRouteRuntimeConfig as dR, mergeFarmRouteRuntimeConfigs as dS, resolveFarmRouteRuntimeConfig as dT, hasFarmRouteRuntimeControls as dU, getFarmRouteRuntimeConfig as dV, createFarmRouteRuntimeKey as dW, resolveFarmRouteRuleRuntimeConfig as dX, farmRouteRuleMatches as dY, DEFAULT_FARM_DEVTOOLS_SHORTCUT as dZ, FARM_DEVTOOLS_PATH as d_, type InferFarmIntegrationOrmClient as da, type CreateIntegrationOrmOptions as db, createIntegrationOrm as dc, resolveIntegrationOrmRuntimeClient as dd, farmIntegrationSchemaToOrmSchema as de, type IntegrationOrmModelNames as df, DEFAULT_FARM_API_BASE_PATH as dg, type FarmAPIConfigResolverContext as dh, type FarmAPIConfigValue as di, type FarmAPIConfig as dj, resolveFarmAPIConfig as dk, normalizeFarmAPIConfig as dl, normalizeFarmAPIBasePath as dm, getFarmAPIBaseURL as dn, resolveFarmAPIRequestURL as dp, type MiddlewareFunction as dq, type RequestMiddleware as dr, type RequestMiddlewareContext as ds, type MiddlewareStore as dt, type MiddlewareChain as du, type CookieJar as dv, type CookieOptions as dw, type RateLimitConfig as dx, type RateLimitIncrementResult as dy, type RateLimitStorage as dz, type FarmAppContext as e, type FarmDevtoolsConfig as e0, type FarmDevtoolsUserConfig as e1, resolveFarmDevtoolsConfig as e2, type FarmBuildActivityPosition as e3, type FarmDevIndicatorsConfig as e4, resolveFarmDevIndicatorsConfig as e5, generateFarmDevIndicatorsClientRuntime as e6, farmI18nClientBridgePlugin as e7, withFarmRequestTracing as e8, rewriteEarlySsrRelativeImports as e9, transformIsolatedClientBoundaryModule as ea, shouldEmitFarmClientRootHmr as eb, generateClientCachePersistenceCode as ec, resolveFarmClientCacheAdapterEntry as ed, type ClientCachePersistenceEntryCode as ee, FARM_NODE_RESPONSE_END_PENDING as ef, type PageProps as f, type PluginContextProps as g, type RouteModule as h, type FarmMdxComponents as i, type FarmMdxResolvedConfig as j, type FarmMdxComponent as k, type FarmMdxUserConfig as l, type FarmUserConfig as m, type FarmContextFactory as n, type MiddlewareProps as o, type FarmIntegration as p, type FarmConfig as q, resolveMdxConfig as r, farmPlugin as s, defineConfig as t, type FarmComponentType as u, type PageRouteParams as v, type FarmMigrationCommand as w, type FarmMigrationsConfig as x, type FarmMigrationsUserConfig as y, type ResolvedFarmMigrationsConfig as z };