@farm.js/core 0.1.0-beta.16 → 0.1.0-beta.17

package/dist/client-plugins-CTQAkr7R.d.ts

@@ -0,0 +1,2021 @@
+import { n as FarmClientPlugin } from './plugin-BJDf43dc.js';
+import React__default, { ComponentType, ReactNode } from 'react';
+import { IncomingMessage, ServerResponse } from 'http';
+import { k as FarmStorageUserConfig } from './types-D1A6-XvH.js';
+import { F as FarmIntegrationAPI, f as FarmIntegrationAPIMethod, e as FarmIntegrationAPIBodyFormat, a as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, h as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes } from './integration-api-CHT2OKAf.js';
+import { OrmClient, SchemaDefinition, ModelDefinition, FieldBuilder, JsonValue, AnyModelDefinition, SchemaModels } from '@farming-labs/orm';
+import { a as FarmDocsUserConfig, F as FarmDocsResolvedConfig } from './types-DTzm4TCl.js';
+import { FarmMarkdownUserConfig, FarmMarkdownResolvedConfig } from './markdown.js';
+import { FarmObservabilityUserConfig } from './observability.js';
+import * as vite from 'vite';
+import { ViteDevServer, UserConfig, Plugin } from 'vite';
+import { FarmWorkflowsUserConfig, FarmWorkflowsResolvedConfig } from './workflows.js';
+import { FarmCronUserConfig, FarmCronResolvedConfig } from './cron.js';
+import { FarmEnvConfig, ResolvedFarmEnv } from './env.js';
+import { FarmServerActionsConfig, ResolvedFarmServerActionsConfig } from './server-action-security.js';
+import { F as FarmImageConfig, R as ResolvedFarmImageConfig } from './image-config-Duob7wER.js';
+import { k as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-BMxWr97v.js';
+import { FarmCacheUserConfig } from './cache.js';
+import { F as FarmRouteRuntimeConfig, a as FarmRouteRuntime, b as FarmRouteRegions, c as FarmRouteMaxDuration } from './route-runtime-DoOHzCAD.js';
+import { FarmLayoutFonts } from './font.js';
+
+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;
+
+/**
+ * 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;
+    delete(name: string): 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;
+}
+interface FarmMarkdownPageSource {
+    source: string;
+    filePath: string;
+}
+interface FarmMarkdownPageModuleInput extends FarmMarkdownPageSource {
+    components?: FarmMdxComponents;
+    config?: FarmMdxResolvedConfig;
+}
+declare function resolveMdxConfig(config: FarmMdxUserConfig | undefined): FarmMdxResolvedConfig;
+declare function isFarmMarkdownPageFile(filePath: string): boolean;
+declare function normalizeFarmMarkdownRoutePath(pathname: string): string;
+declare function parseMarkdownFrontmatter(source: string): {
+    frontmatter: Record<string, string>;
+    body: string;
+};
+declare function titleFromMarkdown(body: string, fallback?: string): string | undefined;
+declare function createMarkdownMetadata(source: string, filePath: string): (Metadata & Record<string, any>) | undefined;
+declare function createFarmMarkdownRouteModule(input: FarmMarkdownPageModuleInput): RouteModule & {
+    source: string;
+};
+declare function createFarmMarkdownRouteModuleFromFile(filePath: string, options?: {
+    components?: FarmMdxComponents;
+    config?: FarmMdxResolvedConfig;
+}): Promise<RouteModule<never> & {
+    source: string;
+}>;
+declare function loadFarmMdxComponents(config: FarmMdxResolvedConfig | undefined, options: {
+    root: string;
+    loadModule?: (modulePath: string) => Promise<unknown>;
+}): Promise<FarmMdxComponents>;
+declare function createFarmMarkdownSourceResponse(options: {
+    request: Request;
+    config?: FarmMdxResolvedConfig;
+    resolveSource: (pathname: string) => Promise<FarmMarkdownPageSource | null> | FarmMarkdownPageSource | null;
+}): Promise<Response | null>;
+
+type FarmRouteRuleRenderMode = "static" | "dynamic";
+type FarmRouteRuleRedirect = string | {
+    to: string;
+    statusCode?: number;
+    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 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 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";
+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;
+
+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 FARM_RESOLVED_CUSTOM_CONTEXT: unique symbol;
+
+interface RedirectConfig {
+    source: string;
+    destination: string;
+    permanent?: boolean;
+    statusCode?: number;
+}
+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;
+    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[];
+    plugins?: FarmPlugin[];
+    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"];
+    serverActions?: FarmServerActionsConfig;
+    /** Build identifier used to detect and recover from deployment version skew. */
+    deploymentId?: string;
+    notFound?: NotFoundConfig;
+    output?: "standalone" | "static" | "export";
+    distDir?: string;
+    generateBuildId?: () => string | Promise<string>;
+    compress?: boolean;
+    devIndicators?: {
+        buildActivity?: boolean;
+        buildActivityPosition?: "bottom-right" | "bottom-left" | "top-right" | "top-left";
+    };
+    serverRuntimeConfig?: Record<string, any>;
+    publicRuntimeConfig?: Record<string, any>;
+    env?: FarmEnvConfig<any, any>;
+    typescript?: {
+        tsconfigPath?: string;
+        ignoreBuildErrors?: boolean;
+    };
+    vite?: UserConfig | ((config: UserConfig) => UserConfig);
+    [key: string]: any;
+}
+interface ResolvedFarmConfig extends Required<Omit<FarmUserConfig, "extends" | "plugins" | "vite" | "deploy" | "docs" | "md" | "mdx" | "migrations" | "cron" | "workflows" | "env" | "serverActions" | "devtools" | "images" | "i18n" | "auth" | "performance" | "security">> {
+    /** @internal Tracks whether `context` came from user/layer config instead of the default noop. */
+    [FARM_RESOLVED_CUSTOM_CONTEXT]?: boolean;
+    extends: readonly FarmLayerEntry[];
+    layers: ResolvedFarmLayer[];
+    plugins: FarmPlugin[];
+    vite: UserConfig;
+    deploy: ResolvedFarmDeployConfig;
+    docs: FarmDocsResolvedConfig;
+    md: FarmMarkdownResolvedConfig;
+    mdx: FarmMdxResolvedConfig;
+    migrations: ResolvedFarmMigrationsConfig;
+    cron: FarmCronResolvedConfig;
+    workflows: FarmWorkflowsResolvedConfig;
+    env: ResolvedFarmEnv;
+    serverActions: ResolvedFarmServerActionsConfig;
+    devtools: ResolvedFarmDevtoolsConfig;
+    images: ResolvedFarmImageConfig;
+    i18n: ResolvedFarmI18nConfig;
+    auth: ResolvedFarmAuthConfig;
+    performance: ResolvedFarmPerformanceConfig;
+    security: ResolvedFarmSecurityConfig;
+    routeRules: FarmRouteRules;
+}
+type FarmLayerConfig = Omit<FarmUserConfig, "root" | "outDir" | "distDir" | "deploy" | "output" | "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;
+}): 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>;
+
+interface FarmVitePluginOptions extends FarmConfig {
+    openapi?: FarmUserConfig["openapi"];
+    images?: FarmUserConfig["images"];
+    publicDir?: FarmUserConfig["publicDir"];
+}
+declare function farmI18nClientBridgePlugin(): Plugin;
+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 farmPlugin(options?: FarmVitePluginOptions, initialPluginManager?: PluginManager): Plugin;
+declare function defineConfig(config?: FarmVitePluginOptions): Promise<UserConfig>;
+
+type MaybePromise$1<T> = T | Promise<T>;
+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 {
+    config: FarmConfig;
+    viteServer?: ViteDevServer;
+    isDev: boolean;
+    isProd: boolean;
+    /** @deprecated Use `ctx.req` inside request hooks. */
+    requestContext: PluginRequestContext;
+}
+interface FarmRequestPluginContext extends FarmPluginContext {
+    /** 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 extends FarmPluginContext {
+    env: ResolvedFarmEnv;
+}
+interface FarmPluginStateContext<TState = unknown> extends FarmPluginContext {
+    state: TState;
+}
+interface FarmPluginRuntimeBaseEvent<TState = unknown> extends FarmPluginStateContext<TState> {
+    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> = FarmPluginRuntimeBaseEvent<TState>;
+interface FarmPluginRuntimeBeforeEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>> extends FarmPluginRuntimeBaseEvent<TState> {
+    ctx: Readonly<TRequestContext>;
+}
+interface FarmPluginRuntimeAfterEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>> extends FarmPluginRuntimeBeforeEvent<TState, TRequestContext> {
+    response: Response;
+    durationMs: number;
+}
+interface FarmPluginRuntimeErrorEvent<TState = unknown, TRequestContext extends object = Record<string, unknown>> extends FarmPluginRuntimeBeforeEvent<TState, TRequestContext> {
+    error: unknown;
+    durationMs: number;
+}
+type FarmPluginRuntimeStartEvent<TState = unknown> = FarmPluginStateContext<TState>;
+interface FarmPluginRuntimeCloseEvent<TState = unknown> extends FarmPluginStateContext<TState>, ShutdownPayload {
+}
+interface FarmPluginRuntimeHooks<TState = unknown, TRequestContext extends object = Record<string, unknown>> {
+    start?(event: FarmPluginRuntimeStartEvent<TState>): MaybePromise$1<void>;
+    context?(event: FarmPluginRuntimeContextEvent<TState>): MaybePromise$1<TRequestContext>;
+    before?(event: FarmPluginRuntimeBeforeEvent<TState, TRequestContext>): MaybePromise$1<Request | Response | void>;
+    after?(event: FarmPluginRuntimeAfterEvent<TState, TRequestContext>): MaybePromise$1<Response | void>;
+    error?(event: FarmPluginRuntimeErrorEvent<TState, TRequestContext>): MaybePromise$1<void>;
+    close?(event: FarmPluginRuntimeCloseEvent<TState>): 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> {
+    discovered?(route: FarmPluginDiscoveredRoute, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+    generated?(routes: RoutesGeneratedPayload, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+    before?(route: RouteMatchPayload, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+    after?(result: RouteMatchResultPayload, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+}
+interface FarmPluginRenderHooks<TState = unknown> {
+    before?(render: RenderLifecyclePayload, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+    html?(html: string, render: RenderLifecyclePayload, context: FarmPluginStateContext<TState>): MaybePromise$1<string | void>;
+}
+interface FarmPluginBuildHooks<TState = unknown> {
+    before?(bundle: BundleLifecyclePayload, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+    configure?(buildConfig: any, context: FarmPluginStateContext<TState>): MaybePromise$1<any>;
+    after?(result: BundleResultPayload, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+}
+interface FarmPluginDevHooks<TState = unknown> {
+    server?(viteServer: ViteDevServer, context: FarmPluginStateContext<TState>): MaybePromise$1<void>;
+    update?(update: HMRUpdatePayload, context: FarmPluginStateContext<TState>): 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> {
+    name: string;
+    version?: string;
+    enforce?: "pre" | "post";
+    /** Transform Farm config before it is resolved. */
+    configure?: (config: FarmConfig, context: FarmPluginContext) => MaybePromise$1<FarmConfig | void>;
+    /** Initialize private plugin state once for this plugin manager. */
+    setup?: (context: FarmPluginSetupContext) => MaybePromise$1<TState>;
+    runtime?: FarmPluginRuntimeHooks<TState, TRequestContext>;
+    router?: FarmPluginRouterHooks<TState>;
+    render?: FarmPluginRenderHooks<TState>;
+    build?: FarmPluginBuildHooks<TState>;
+    dev?: FarmPluginDevHooks<TState>;
+    /** Optional browser lifecycle for this logical plugin. */
+    client?: FarmPluginClientConfig<TClientState, TClientPublic>;
+    /** @deprecated Use `setup` instead. */
+    init?: (context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `runtime.start` instead. */
+    ready?: (context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `dev.server` instead. */
+    devServerCreated?: (viteServer: ViteDevServer, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `configure` instead. */
+    config?: (config: FarmConfig, context: FarmPluginContext) => FarmConfig | Promise<FarmConfig>;
+    configResolved?: (config: FarmConfig, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `build.before` instead. */
+    buildStart?: (context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `build.after` instead. */
+    buildEnd?: (context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `router.discovered` instead. */
+    routeDiscovered?: (route: RouteDiscoveredPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `router.generated` instead. */
+    routesGenerated?: (routes: RoutesGeneratedPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `router.discovered` instead. */
+    middlewareDiscovered?: (middleware: MiddlewareDiscoveredPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `router.discovered` instead. */
+    apiRouteDiscovered?: (route: APIRouteDiscoveredPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `router.before` instead. */
+    beforeRouteMatch?: (route: RouteMatchPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `router.after` instead. */
+    afterRouteMatch?: (result: RouteMatchResultPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `render.before` instead. */
+    beforeRender?: (render: RenderLifecyclePayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `render.html` instead. */
+    afterRender?: (html: string, render: RenderLifecyclePayload, context: FarmPluginContext) => string | Promise<string> | void | Promise<void>;
+    /** @deprecated Use `runtime.before` instead. */
+    beforeApiHandler?: (request: Request, api: APIHandlerLifecyclePayload, context: FarmRequestPluginContext) => Request | Promise<Request> | void | Promise<void>;
+    /** @deprecated Use `runtime.after` instead. */
+    afterApiHandler?: (response: Response, api: APIHandlerLifecyclePayload, context: FarmPluginContext) => Response | Promise<Response> | void | Promise<void>;
+    onError?: (error: ErrorLifecyclePayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `dev.update` instead. */
+    hmrUpdate?: (update: HMRUpdatePayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `build.before` instead. */
+    beforeBundle?: (bundle: BundleLifecyclePayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `build.after` instead. */
+    afterBundle?: (result: BundleResultPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `build.configure` instead. */
+    beforeNitroBuild?: (nitroConfig: any, context: FarmPluginContext) => any | Promise<any>;
+    afterNitroBuild?: (payload: NitroBuildLifecyclePayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use `runtime.close` instead. */
+    shutdown?: (payload: ShutdownPayload, context: FarmPluginContext) => void | Promise<void>;
+    /** @deprecated Use the Web Request based `runtime.before` hook instead. */
+    beforeRequest?: (req: FarmRequest, res: FarmResponse, context: FarmRequestPluginContext) => void | Promise<void>;
+    /** @deprecated Use the Web Response based `runtime.after` hook instead. */
+    afterResponse?: (req: FarmRequest, res: FarmResponse, context: FarmRequestPluginContext) => void | Promise<void>;
+    /** @deprecated Use `render.html` instead. */
+    transformHTML?: (html: string, context: FarmPluginContext) => string | Promise<string>;
+    /** @deprecated Use `render.before` or `render.html` instead. */
+    transformPage?: (component: any, context: FarmPluginContext) => 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 runtimeRequestContexts;
+    private failedRuntimeSessions;
+    constructor(context: Omit<FarmPluginContext, "requestContext">);
+    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>;
+    updateContext(updates: Partial<FarmPluginContext>): void;
+}
+declare function definePlugin<TState = undefined, TRequestContext extends object = Record<string, never>, TClientState = unknown, TClientPublic = undefined>(plugin: FarmPlugin<TState, TRequestContext, TClientState, TClientPublic>): FarmPlugin<TState, TRequestContext, TClientState, TClientPublic>;
+
+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";
+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 FarmIntegrationProvider {
+    name: string;
+    type: string;
+    props?: Record<string, unknown>;
+    component?: ComponentType<FarmIntegrationProviderProps>;
+}
+interface FarmIntegrationDocumentNavigation {
+    matcher: string | readonly string[];
+}
+type FarmIntegrationSchemaFieldType = "id" | "uuid" | "string" | "text" | "boolean" | "integer" | "number" | "datetime" | "json" | "enum";
+interface FarmIntegrationSchemaReference {
+    model: string;
+    field: string;
+    relation?: "belongsTo" | "hasOne" | "hasMany";
+    onDelete?: "cascade" | "restrict" | "setNull" | "noAction";
+    enforced?: "db" | "app" | "none";
+}
+interface FarmIntegrationSchemaField {
+    type: FarmIntegrationSchemaFieldType;
+    name?: string;
+    description?: string;
+    required?: boolean;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    index?: boolean;
+    list?: boolean;
+    default?: unknown;
+    values?: readonly string[];
+    reference?: FarmIntegrationSchemaReference;
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaConstraint {
+    type: "unique" | "index";
+    fields: readonly string[];
+    name?: string;
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaModel {
+    name?: string;
+    description?: string;
+    fields: Record<string, FarmIntegrationSchemaField>;
+    constraints?: readonly FarmIntegrationSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaModelExtension {
+    name?: string;
+    description?: string;
+    fields?: Record<string, FarmIntegrationSchemaField>;
+    constraints?: readonly FarmIntegrationSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchemaModelOverride {
+    name?: string;
+    description?: string;
+    fields?: Record<string, Partial<FarmIntegrationSchemaField>>;
+    constraints?: readonly FarmIntegrationSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmIntegrationSchema {
+    models: Record<string, FarmIntegrationSchemaModel>;
+    meta?: Record<string, unknown>;
+    extend?: Record<string, FarmIntegrationSchemaModelExtension>;
+    override?: Record<string, FarmIntegrationSchemaModelOverride>;
+}
+declare function defineIntegrationSchema<TSchema extends FarmIntegrationSchema>(schema: TSchema): TSchema;
+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 FarmIntegration<TSchema extends FarmIntegrationSchema | undefined = FarmIntegrationSchema | undefined, TConfig = unknown> {
+    readonly kind: "farm-integration";
+    category: FarmIntegrationCategory;
+    /** @deprecated Use category instead. */
+    slot?: FarmIntegrationCategory;
+    type: string;
+    instance: unknown;
+    /** 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[];
+    plugins?: readonly FarmPlugin[];
+}
+type FarmIntegrationsUserConfig = Record<string, FarmIntegration<any, any> | undefined>;
+/** @internal Identifies lifecycle plugins owned by platform-managed integrations. */
+declare function getFarmIntegrationPluginServerRuntime(plugin: FarmPlugin): boolean | 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>;
+    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> = Omit<FarmIntegration<TSchema, TConfig>, "kind" | "category" | "slot" | "config" | "routes" | "endpoints"> & {
+    config?: FarmIntegrationConfigInput<TConfig, TSchema>;
+    routes?: FarmIntegrationRoutesInput<TSchema>;
+    endpoints?: FarmIntegrationEndpointsInput<TSchema>;
+} & ({
+    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>>(integration: TIntegration & FarmIntegrationInput<TSchema, TConfig>): DefinedIntegration<TIntegration, TSchema>;
+declare function isFarmIntegration(value: unknown): value is FarmIntegration;
+declare function resolveIntegrationPlugins(integrations: FarmIntegrationsUserConfig | undefined): FarmPlugin[];
+declare function getIntegrationProviders(integrations: FarmIntegrationsUserConfig | undefined): Array<Pick<FarmIntegrationProvider, "name" | "type" | "props">>;
+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 {
+        }
+    }
+}
+/** 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;
+    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;
+    env?: FarmEnvConfig<any, any> | ResolvedFarmEnv;
+    middleware?: FarmMiddlewareConfig;
+    routeRules?: FarmRouteRules;
+    context?: FarmContextFactory<any>;
+    serverActions?: FarmServerActionsConfig;
+    /** App-wide HTTP security policy. */
+    security?: FarmSecurityConfig | ResolvedFarmSecurityConfig;
+    images?: FarmImageConfig;
+    /** Browser resource scheduling and preload budgets. */
+    performance?: FarmPerformanceConfig;
+    i18n?: FarmI18nUserConfig | ResolvedFarmI18nConfig | false;
+    /** Build identifier used to detect stale clients during rolling deployments. */
+    deploymentId?: string;
+    docs?: FarmDocsUserConfig | FarmDocsResolvedConfig;
+    md?: FarmMarkdownUserConfig | FarmMarkdownResolvedConfig | boolean;
+    mdx?: FarmMdxUserConfig | FarmMdxResolvedConfig;
+    observability?: FarmObservabilityUserConfig;
+    /** Development-only runtime inspector. Enabled by default during `farm dev`. */
+    devtools?: FarmDevtoolsUserConfig;
+    /**
+     * 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;
+        /**
+         * 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;
+}
+/**
+ * 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: ReactNode;
+    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> = ComponentType<PageProps<TRoute>>;
+type Layout<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = ComponentType<LayoutProps<TRoute>>;
+type Loading<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = ComponentType<LoadingProps<TRoute>>;
+type ErrorBoundary<TRoute extends FarmRoutePropsTarget = FarmRoutePropsDefault> = ComponentType<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`.
+     */
+    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 FarmPlugin as $, type AppRoutePattern as A, type RouteSegment as B, type ParsedRoute as C, type BuildOptions as D, type ErrorProps as E, type FarmConfig as F, type GenerateStaticParams as G, type SSGPage as H, type SSGCollectionResult as I, type FarmLayerEntry as J, type ResolvedFarmLayer as K, type LoadingProps as L, type MiddlewareProps as M, type NitroPreset as N, type FarmSourceRoot as O, type PageRouteParams as P, type ResolveFarmLayersOptions as Q, type ResolvedFarmMigrationsConfig as R, type StaticPathPrimitive as S, type FarmLayerResolution as T, resolveFarmLayers as U, getFarmSourceRoots as V, getFarmAppDirectories as W, getFarmLayerAliases as X, loadFarmConfigFile as Y, type FarmUserConfig as Z, type BundleResultPayload as _, type FarmMigrationCommand as a, type FarmPluginDevHooks as a$, type FarmIntegration as a0, type ReadonlyMiddlewareStore as a1, type FarmMiddlewareConfig as a2, type MiddlewareModule as a3, manageFarmDocumentPreloads as a4, manageFarmHtmlPreloads as a5, manageFarmLinkHeaderPreloads as a6, reportFarmPreloadWarnings as a7, type FarmMdxResolvedConfig as a8, type ResolvedFarmDevtoolsConfig as a9, type FarmAuthDatabaseConfig as aA, type FarmAuthEmailAndPasswordConfig as aB, type FarmAuthSessionConfig as aC, type FarmAuthUserConfig as aD, type PluginRequestContext as aE, type FarmPluginContext as aF, type FarmRequestPluginContext as aG, type FarmRequestStore as aH, type FarmPluginRuntimeKind as aI, type FarmPluginRouteRuntimePayload as aJ, type FarmPluginSetupContext as aK, type FarmPluginStateContext as aL, type FarmPluginRuntimeBaseEvent as aM, type FarmPluginRuntimeContextEvent as aN, type FarmPluginRuntimeBeforeEvent as aO, type FarmPluginRuntimeAfterEvent as aP, type FarmPluginRuntimeErrorEvent as aQ, type FarmPluginRuntimeStartEvent as aR, type FarmPluginRuntimeCloseEvent as aS, type FarmPluginRuntimeHooks as aT, type FarmPluginRuntimeRequestOptions as aU, type FarmPluginRuntimeRequestHandler as aV, type FarmPluginRuntimeSession as aW, type FarmPluginDiscoveredRoute as aX, type FarmPluginRouterHooks as aY, type FarmPluginRenderHooks as aZ, type FarmPluginBuildHooks as a_, type ResolvedFarmAuthConfig as aa, type ResolvedFarmPerformanceConfig as ab, type ResolvedFarmSecurityConfig as ac, type OpenAPIConfig as ad, definePlugin as ae, PluginManager as af, resolveConfig as ag, loadConfig as ah, resolveDeployConfig as ai, resolveMigrationsConfig as aj, resolveDeployOutputPath as ak, normalizeDeployTarget as al, getDeployTargetForPreset as am, getPresetForDeployTarget as an, type FarmLayerConfig as ao, type FarmPerformanceConfig as ap, type FarmPreloadMode as aq, type FarmPreloadUserConfig as ar, type ResolvedFarmPreloadConfig as as, type FarmCspConfig as at, type FarmCspDirectives as au, type FarmCspDirectiveValue as av, type FarmCspOptions as aw, type FarmSecurityConfig as ax, type ResolvedFarmCspConfig as ay, type FarmAuthConfig as az, type FarmMigrationsConfig as b, type FarmIntegrationSchemaField as b$, type FarmPluginClientConfig as b0, type RouteDiscoveredPayload as b1, type RoutesGeneratedPayload as b2, type MiddlewareDiscoveredPayload as b3, type APIRouteDiscoveredPayload as b4, type RouteMatchPayload as b5, type RouteMatchResultPayload as b6, type RenderLifecyclePayload as b7, type APIHandlerLifecyclePayload as b8, type ErrorLifecyclePayload as b9, type FarmIntegrationInputSchema as bA, type FarmIntegrationRouteInputSchemas as bB, type FarmIntegrationRequestContextStore as bC, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as bD, type FarmIntegrationRouteDb as bE, type FarmIntegrationRouteStorageArgs as bF, type FarmIntegrationRouteArgs as bG, type FarmIntegrationConfigContext as bH, type FarmIntegrationConfigDefinition as bI, type FarmIntegrationConfigInput as bJ, type FarmIntegrationLifecycleLogLevel as bK, type FarmIntegrationLifecycleLogger as bL, type FarmIntegrationLifecycleContext as bM, type FarmIntegrationLifecycleHook as bN, type FarmIntegrationData as bO, type FarmIntegrationHandlerContext as bP, type FarmIntegrationRouteHookContext as bQ, type FarmIntegrationRouteHook as bR, type FarmIntegrationRoute as bS, type FarmTypedIntegrationRoute as bT, type FarmIntegrationRouteMiddleware as bU, type FarmIntegrationMiddleware as bV, type FarmIntegrationProviderProps as bW, type FarmIntegrationProvider as bX, type FarmIntegrationDocumentNavigation as bY, type FarmIntegrationSchemaFieldType as bZ, type FarmIntegrationSchemaReference as b_, type HMRUpdatePayload as ba, type BundleLifecyclePayload as bb, type NitroBuildLifecyclePayload as bc, type ShutdownPayload as bd, type ResolvedFarmConfig as be, type RedirectConfig as bf, type HeaderConfig as bg, type RewriteConfig as bh, type ImageConfig as bi, type I18nConfig as bj, type MiddlewareConfig as bk, type FarmDeployConfig as bl, type ResolvedFarmDeployConfig as bm, type FarmDeployTarget as bn, type FarmIntegrationCategory as bo, type FarmIntegrationSlot as bp, type FarmIntegrationRouteParamValue as bq, type FarmIntegrationRouteParams as br, type FarmIntegrationRouteMethod as bs, type FarmIntegrationRouteInputSource as bt, type FarmIntegrationValidationPathSegment as bu, type FarmIntegrationRouteInput as bv, type FarmIntegrationValidationIssue as bw, type FarmIntegrationValidationErrorLike as bx, type FarmIntegrationValidationResult as by, type FarmIntegrationStandardValidationResult as bz, type FarmMigrationsUserConfig as c, type FarmRouteRule as c$, type FarmIntegrationSchemaConstraint as c0, type FarmIntegrationSchemaModel as c1, type FarmIntegrationSchemaModelExtension as c2, type FarmIntegrationSchemaModelOverride as c3, type FarmIntegrationSchema as c4, defineIntegrationSchema as c5, type FarmIntegrationLogPhase as c6, type FarmIntegrationLogEvent as c7, type FarmIntegrationLogger as c8, type FarmIntegrationsUserConfig as c9, type InferFarmIntegrationOrmField as cA, type InferFarmIntegrationOrmFields as cB, type InferFarmIntegrationOrmSchema as cC, type InferFarmIntegrationOrmClient as cD, type CreateIntegrationOrmOptions as cE, createIntegrationOrm as cF, resolveIntegrationOrmRuntimeClient as cG, farmIntegrationSchemaToOrmSchema as cH, type IntegrationOrmModelNames as cI, type MiddlewareContext as cJ, type MiddlewareFunction as cK, type RequestMiddleware as cL, type RequestMiddlewareContext as cM, type MiddlewareStore as cN, type MiddlewareChain as cO, type CookieJar as cP, type CookieOptions as cQ, type RateLimitConfig as cR, type RateLimitIncrementResult as cS, type RateLimitStorage as cT, type RateLimitStatus as cU, type MemoryRateLimitStorageOptions as cV, type NextFunction as cW, type MiddlewareResult as cX, type FarmRouteRuleRenderMode as cY, type FarmRouteRuleRedirect as cZ, type FarmRouteRuleCors as c_, getFarmIntegrationPluginServerRuntime as ca, type FarmIntegrationRouteFactory as cb, type FarmIntegrationRoutesFactoryContext as cc, type FarmIntegrationRoutesFactory as cd, type FarmIntegrationEndpointValue as ce, type FarmIntegrationEndpoints as cf, type FarmIntegrationEndpointsFactoryContext as cg, type FarmIntegrationEndpointsFactory as ch, createIntegrationRoute as ci, integrationRoute as cj, type DefinedIntegration as ck, defineIntegration as cl, isFarmIntegration as cm, resolveIntegrationPlugins as cn, getIntegrationProviders as co, getIntegrationDocumentNavigationMatchers as cp, getIntegrationSchemas as cq, getRegisteredIntegrationRuntime as cr, getRegisteredIntegrations as cs, getRegisteredIntegrationSchemas as ct, matchIntegrationRoute as cu, matchRegisteredIntegrationRoute as cv, getRegisteredIntegrationAPIManifest as cw, dispatchIntegrationRequest as cx, type FarmIntegrationOrmSchema as cy, type FarmIntegrationOrmClient as cz, defineConfig as d, type FarmRouteRules as d0, normalizeRouteRules as d1, routeRulesToRedirects as d2, routeRulesToHeaders as d3, routeRulesToNitroRouteRules as d4, type FarmMdxComponent as d5, type FarmMdxComponents as d6, type FarmMdxUserConfig as d7, type FarmMarkdownPageSource as d8, type FarmMarkdownPageModuleInput as d9, resolveMdxConfig as da, isFarmMarkdownPageFile as db, normalizeFarmMarkdownRoutePath as dc, parseMarkdownFrontmatter as dd, titleFromMarkdown as de, createMarkdownMetadata as df, createFarmMarkdownRouteModule as dg, createFarmMarkdownRouteModuleFromFile as dh, loadFarmMdxComponents as di, createFarmMarkdownSourceResponse as dj, DEFAULT_FARM_DEVTOOLS_SHORTCUT as dk, FARM_DEVTOOLS_PATH as dl, FARM_DEVTOOLS_LAUNCH_PARAM as dm, type FarmDevtoolsConfig as dn, type FarmDevtoolsUserConfig as dp, resolveFarmDevtoolsConfig as dq, type MiddlewareConfig$1 as dr, farmI18nClientBridgePlugin as ds, rewriteEarlySsrRelativeImports as dt, type FarmContextFactoryInput as e, farmPlugin as f, type FarmContextFactory as g, type FarmAppContext as h, type PluginContextProps as i, type PageProps as j, type PagePropsWithMiddleware as k, type LayoutProps as l, type MetadataProps as m, type LayoutMetadataProps as n, type Page as o, type Layout as p, type Loading as q, type ErrorBoundary as r, type RouteModule as s, type StaticPathParams as t, type StaticRouteParams as u, type LayoutModule as v, type Metadata as w, type FarmRequest as x, type FarmResponse as y, type ServerAction as z };