@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/client-plugins-BI2R6Eae.d.mts

@@ -0,0 +1,1926 @@
+import { n as FarmClientPlugin } from './plugin-BJDf43dc.mjs';
+import React__default, { ComponentType, ReactNode } from 'react';
+import { IncomingMessage, ServerResponse } from 'http';
+import { k as FarmStorageUserConfig } from './types-D1A6-XvH.mjs';
+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.mjs';
+import { OrmClient, SchemaDefinition, ModelDefinition, FieldBuilder, JsonValue, AnyModelDefinition, SchemaModels } from '@farming-labs/orm';
+import { a as FarmDocsUserConfig, F as FarmDocsResolvedConfig } from './types-C9N-nk5R.mjs';
+import { FarmMarkdownUserConfig, FarmMarkdownResolvedConfig } from './markdown.mjs';
+import { FarmObservabilityUserConfig } from './observability.mjs';
+import * as vite from 'vite';
+import { ViteDevServer, UserConfig, Plugin } from 'vite';
+import { FarmWorkflowsUserConfig, FarmWorkflowsResolvedConfig } from './workflows.mjs';
+import { FarmCronUserConfig, FarmCronResolvedConfig } from './cron.mjs';
+import { FarmEnvConfig, ResolvedFarmEnv } from './env.mjs';
+import { FarmServerActionsConfig, ResolvedFarmServerActionsConfig } from './server-action-security.mjs';
+import { F as FarmImageConfig, R as ResolvedFarmImageConfig } from './image-config-Duob7wER.mjs';
+import { k as FarmI18nUserConfig, R as ResolvedFarmI18nConfig } from './types-BMxWr97v.mjs';
+import { FarmCacheUserConfig } from './cache.mjs';
+import { F as FarmRouteRuntimeConfig, a as FarmRouteRuntime, b as FarmRouteRegions, c as FarmRouteMaxDuration } from './route-runtime-DoOHzCAD.mjs';
+
+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 RateLimitStorage {
+    get(key: string): Promise<any> | any;
+    set(key: string, value: any, ttl?: number): Promise<void> | void;
+    delete(key: string): Promise<void> | void;
+    ttl?(key: string): Promise<number | null> | number | null;
+}
+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 & {
+    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;
+    };
+}
+
+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">> {
+    /** @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;
+    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"];
+}
+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<{
+    plugins: (Plugin<any> | {
+        name: string;
+        enforce: "pre";
+        resolveId(id: string): string | null;
+    } | {
+        name: string;
+        enforce: "pre";
+        configureServer(server: ViteDevServer): void;
+    } | Plugin<any>[])[];
+    customLogger: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        warnOnce: (msg: string) => void;
+        error: (msg: string) => void;
+        clearScreen: () => void;
+        hasErrorLogged: () => boolean;
+        hasWarned: boolean;
+    };
+    clearScreen: boolean;
+    optimizeDeps: {
+        include: string[];
+        exclude: string[];
+    };
+    ssr: {
+        noExternal: string[];
+        external: string[];
+    };
+    resolve: {
+        dedupe: string[];
+        alias: {
+            "@": string;
+            "supports-color": string;
+            "@poppinss/dumper": string;
+            "@poppinss/dumper/html": string;
+            "consola/basic": string;
+            youch: string;
+        };
+    };
+    define: {
+        __FARM_DEV__: string;
+        __FARM_PUBLIC_ENV__: string;
+    };
+}>;
+
+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>;
+
+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;
+    images?: FarmImageConfig;
+    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;
+        /**
+         * Enable server-only optimized boundaries for host-only content. Boundary
+         * interiors cannot contain Client Components, event handlers, or
+         * independently updating React state.
+         *
+         * @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 {
+    params: Record<string, string>;
+    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 {
+    params: Record<string, string>;
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+    search?: Record<string, string | string[] | undefined>;
+    path: string;
+    middleware?: MiddlewareProps;
+    context?: PluginContextProps;
+}
+interface ErrorProps extends LoadingProps {
+    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>> = PageProps & {
+    middleware: {
+        data: Map<keyof T, T[keyof T]>;
+    };
+};
+interface LayoutProps {
+    children: ReactNode;
+    params: Record<string, string>;
+}
+type Page = ComponentType<PageProps>;
+type Layout = ComponentType<LayoutProps>;
+type Loading = ComponentType<LoadingProps>;
+type ErrorBoundary = ComponentType<ErrorProps>;
+/**
+ * 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 {
+    default?: Page;
+    /** 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?: () => Promise<StaticPathParams[]> | StaticPathParams[];
+    /**
+     * @deprecated Use getStaticPaths instead
+     */
+    generateStaticParams?: () => Promise<StaticPathParams[]> | StaticPathParams[];
+    metadata?: Metadata & Record<string, any>;
+    generateMetadata?: (props: PageProps) => 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[]>;
+interface LayoutModule {
+    default: Layout;
+    runtime?: FarmRouteRuntime;
+    regions?: FarmRouteRegions;
+    maxDuration?: FarmRouteMaxDuration;
+    metadata?: Metadata & Record<string, any>;
+    generateMetadata?: (props: {
+        params: Record<string, string>;
+    }) => 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 ResolvedFarmDevtoolsConfig as $, type FarmLayerEntry as A, type BuildOptions as B, type ResolvedFarmLayer as C, type FarmSourceRoot as D, type ErrorProps as E, type FarmConfig as F, type ResolveFarmLayersOptions as G, type FarmLayerResolution as H, resolveFarmLayers as I, getFarmSourceRoots as J, getFarmAppDirectories as K, type LoadingProps as L, type MiddlewareProps as M, type NitroPreset as N, getFarmLayerAliases as O, type PluginContextProps as P, loadFarmConfigFile as Q, type ResolvedFarmMigrationsConfig as R, type StaticPathPrimitive as S, type FarmUserConfig as T, type BundleResultPayload as U, type FarmPlugin as V, type FarmIntegration as W, type ReadonlyMiddlewareStore as X, type FarmMiddlewareConfig as Y, type MiddlewareModule as Z, type FarmMdxResolvedConfig as _, type FarmMigrationCommand as a, type FarmDeployConfig as a$, type ResolvedFarmAuthConfig as a0, type OpenAPIConfig as a1, definePlugin as a2, PluginManager as a3, resolveConfig as a4, loadConfig as a5, resolveDeployConfig as a6, resolveMigrationsConfig as a7, resolveDeployOutputPath as a8, normalizeDeployTarget as a9, type FarmPluginRuntimeSession as aA, type FarmPluginDiscoveredRoute as aB, type FarmPluginRouterHooks as aC, type FarmPluginRenderHooks as aD, type FarmPluginBuildHooks as aE, type FarmPluginDevHooks as aF, type FarmPluginClientConfig as aG, type RouteDiscoveredPayload as aH, type RoutesGeneratedPayload as aI, type MiddlewareDiscoveredPayload as aJ, type APIRouteDiscoveredPayload as aK, type RouteMatchPayload as aL, type RouteMatchResultPayload as aM, type RenderLifecyclePayload as aN, type APIHandlerLifecyclePayload as aO, type ErrorLifecyclePayload as aP, type HMRUpdatePayload as aQ, type BundleLifecyclePayload as aR, type NitroBuildLifecyclePayload as aS, type ShutdownPayload as aT, type ResolvedFarmConfig as aU, type RedirectConfig as aV, type HeaderConfig as aW, type RewriteConfig as aX, type ImageConfig as aY, type I18nConfig as aZ, type MiddlewareConfig as a_, getDeployTargetForPreset as aa, getPresetForDeployTarget as ab, type FarmLayerConfig as ac, type FarmAuthConfig as ad, type FarmAuthDatabaseConfig as ae, type FarmAuthEmailAndPasswordConfig as af, type FarmAuthSessionConfig as ag, type FarmAuthUserConfig as ah, type PluginRequestContext as ai, type FarmPluginContext as aj, type FarmRequestPluginContext as ak, type FarmRequestStore as al, type FarmPluginRuntimeKind as am, type FarmPluginRouteRuntimePayload as an, type FarmPluginSetupContext as ao, type FarmPluginStateContext as ap, type FarmPluginRuntimeBaseEvent as aq, type FarmPluginRuntimeContextEvent as ar, type FarmPluginRuntimeBeforeEvent as as, type FarmPluginRuntimeAfterEvent as at, type FarmPluginRuntimeErrorEvent as au, type FarmPluginRuntimeStartEvent as av, type FarmPluginRuntimeCloseEvent as aw, type FarmPluginRuntimeHooks as ax, type FarmPluginRuntimeRequestOptions as ay, type FarmPluginRuntimeRequestHandler as az, type FarmMigrationsConfig as b, defineIntegration as b$, type ResolvedFarmDeployConfig as b0, type FarmDeployTarget as b1, type FarmIntegrationCategory as b2, type FarmIntegrationSlot as b3, type FarmIntegrationRouteParamValue as b4, type FarmIntegrationRouteParams as b5, type FarmIntegrationRouteMethod as b6, type FarmIntegrationRouteInputSource as b7, type FarmIntegrationValidationPathSegment as b8, type FarmIntegrationRouteInput as b9, type FarmIntegrationProviderProps as bA, type FarmIntegrationProvider as bB, type FarmIntegrationDocumentNavigation as bC, type FarmIntegrationSchemaFieldType as bD, type FarmIntegrationSchemaReference as bE, type FarmIntegrationSchemaField as bF, type FarmIntegrationSchemaConstraint as bG, type FarmIntegrationSchemaModel as bH, type FarmIntegrationSchemaModelExtension as bI, type FarmIntegrationSchemaModelOverride as bJ, type FarmIntegrationSchema as bK, defineIntegrationSchema as bL, type FarmIntegrationLogPhase as bM, type FarmIntegrationLogEvent as bN, type FarmIntegrationLogger as bO, type FarmIntegrationsUserConfig as bP, getFarmIntegrationPluginServerRuntime as bQ, type FarmIntegrationRouteFactory as bR, type FarmIntegrationRoutesFactoryContext as bS, type FarmIntegrationRoutesFactory as bT, type FarmIntegrationEndpointValue as bU, type FarmIntegrationEndpoints as bV, type FarmIntegrationEndpointsFactoryContext as bW, type FarmIntegrationEndpointsFactory as bX, createIntegrationRoute as bY, integrationRoute as bZ, type DefinedIntegration as b_, type FarmIntegrationValidationIssue as ba, type FarmIntegrationValidationErrorLike as bb, type FarmIntegrationValidationResult as bc, type FarmIntegrationStandardValidationResult as bd, type FarmIntegrationInputSchema as be, type FarmIntegrationRouteInputSchemas as bf, type FarmIntegrationRequestContextStore as bg, FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY as bh, type FarmIntegrationRouteDb as bi, type FarmIntegrationRouteStorageArgs as bj, type FarmIntegrationRouteArgs as bk, type FarmIntegrationConfigContext as bl, type FarmIntegrationConfigDefinition as bm, type FarmIntegrationConfigInput as bn, type FarmIntegrationLifecycleLogLevel as bo, type FarmIntegrationLifecycleLogger as bp, type FarmIntegrationLifecycleContext as bq, type FarmIntegrationLifecycleHook as br, type FarmIntegrationData as bs, type FarmIntegrationHandlerContext as bt, type FarmIntegrationRouteHookContext as bu, type FarmIntegrationRouteHook as bv, type FarmIntegrationRoute as bw, type FarmTypedIntegrationRoute as bx, type FarmIntegrationRouteMiddleware as by, type FarmIntegrationMiddleware as bz, type FarmMigrationsUserConfig as c, type FarmDevtoolsConfig as c$, isFarmIntegration as c0, resolveIntegrationPlugins as c1, getIntegrationProviders as c2, getIntegrationDocumentNavigationMatchers as c3, getIntegrationSchemas as c4, getRegisteredIntegrationRuntime as c5, getRegisteredIntegrations as c6, getRegisteredIntegrationSchemas as c7, matchIntegrationRoute as c8, matchRegisteredIntegrationRoute as c9, type FarmRouteRuleRenderMode as cA, type FarmRouteRuleRedirect as cB, type FarmRouteRuleCors as cC, type FarmRouteRule as cD, type FarmRouteRules as cE, normalizeRouteRules as cF, routeRulesToRedirects as cG, routeRulesToHeaders as cH, routeRulesToNitroRouteRules as cI, type FarmMdxComponent as cJ, type FarmMdxComponents as cK, type FarmMdxUserConfig as cL, type FarmMarkdownPageSource as cM, type FarmMarkdownPageModuleInput as cN, resolveMdxConfig as cO, isFarmMarkdownPageFile as cP, normalizeFarmMarkdownRoutePath as cQ, parseMarkdownFrontmatter as cR, titleFromMarkdown as cS, createMarkdownMetadata as cT, createFarmMarkdownRouteModule as cU, createFarmMarkdownRouteModuleFromFile as cV, loadFarmMdxComponents as cW, createFarmMarkdownSourceResponse as cX, DEFAULT_FARM_DEVTOOLS_SHORTCUT as cY, FARM_DEVTOOLS_PATH as cZ, FARM_DEVTOOLS_LAUNCH_PARAM as c_, getRegisteredIntegrationAPIManifest as ca, dispatchIntegrationRequest as cb, type FarmIntegrationOrmSchema as cc, type FarmIntegrationOrmClient as cd, type InferFarmIntegrationOrmField as ce, type InferFarmIntegrationOrmFields as cf, type InferFarmIntegrationOrmSchema as cg, type InferFarmIntegrationOrmClient as ch, type CreateIntegrationOrmOptions as ci, createIntegrationOrm as cj, resolveIntegrationOrmRuntimeClient as ck, farmIntegrationSchemaToOrmSchema as cl, type IntegrationOrmModelNames as cm, type MiddlewareContext as cn, type MiddlewareFunction as co, type RequestMiddleware as cp, type RequestMiddlewareContext as cq, type MiddlewareStore as cr, type MiddlewareChain as cs, type CookieJar as ct, type CookieOptions as cu, type RateLimitConfig as cv, type RateLimitStorage as cw, type RateLimitStatus as cx, type NextFunction as cy, type MiddlewareResult as cz, defineConfig as d, type FarmDevtoolsUserConfig as d0, resolveFarmDevtoolsConfig as d1, type MiddlewareConfig$1 as d2, farmI18nClientBridgePlugin as d3, rewriteEarlySsrRelativeImports as d4, type FarmContextFactoryInput as e, farmPlugin as f, type FarmContextFactory as g, type FarmAppContext as h, type PageProps as i, type PagePropsWithMiddleware as j, type LayoutProps as k, type Page as l, type Layout as m, type Loading as n, type ErrorBoundary as o, type RouteModule as p, type StaticPathParams as q, type LayoutModule as r, type Metadata as s, type FarmRequest as t, type FarmResponse as u, type ServerAction as v, type RouteSegment as w, type ParsedRoute as x, type SSGPage as y, type SSGCollectionResult as z };