@farm.js/core 0.1.61 → 0.1.63

package/dist/index.d.ts

@@ -0,0 +1,1053 @@
+import { bO as ResolvedSchemaField, bP as FarmSqlStatement, bQ as FarmSqlDialect, bR as CollectedSchemaModel, bS as FarmSchemaMigrationStep, aF as FarmConfig, bT as OpenAPIConfig, F as FarmPlugin } from './client-plugins.d-BgPUYPc9.js';
+export { T as APIHandlerLifecyclePayload, U as APIRouteDiscoveredPayload, aG as AppRoutePattern, bU as ApplyMarkdownNegotiationHeadersOptions, aH as BuildOptions, V as BundleLifecyclePayload, B as BundleResultPayload, bV as CookieJar, bW as CookieOptions, bX as CreateIntegrationOrmOptions, bY as CreateMarkdownMirrorResponseOptions, bZ as DEFAULT_FARM_API_BASE_PATH, b_ as DEFAULT_FARM_DEVTOOLS_SHORTCUT, b$ as DefinedIntegration, aI as ErrorBoundary, W as ErrorLifecyclePayload, aJ as ErrorProps, c0 as FARM_DEVTOOLS_LAUNCH_PARAM, c1 as FARM_DEVTOOLS_PATH, c2 as FARM_INTEGRATION_API_BASE_PATH_KEY, c3 as FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY, c4 as FARM_INTEGRATION_SET_COOKIES_KEY, j as FARM_MARKDOWN_CONTENT_TYPE, c5 as FARM_MARKDOWN_PAGE_CHECK_HEADER, c6 as FarmAPIConfig, c7 as FarmAPIConfigResolverContext, c8 as FarmAPIConfigValue, c9 as FarmAgentCrawlers, bp as FarmAgentJsonLd, ca as FarmAgentUserConfig, v as FarmAppContext, cb as FarmAppManifestConfig, cc as FarmAuthConfig, cd as FarmAuthDatabaseConfig, ce as FarmAuthEmailAndPasswordConfig, cf as FarmAuthSessionConfig, cg as FarmAuthUserConfig, ch as FarmBuildActivityPosition, aK as FarmComponentType, aL as FarmContextFactory, aM as FarmContextFactoryInput, ci as FarmCrawlerPolicy, cj as FarmCspConfig, ck as FarmCspDirectiveValue, cl as FarmCspDirectives, cm as FarmCspOptions, cn as FarmDeployConfig, co as FarmDeployTarget, cp as FarmDevIndicatorsConfig, cq as FarmDevtoolsConfig, Y as FarmDevtoolsUserConfig, cr as FarmDocsConfigInput, cs as FarmDocsNavigationConfig, by as FarmDocsResolvedConfig, ct as FarmDocsResolvedRoot, cu as FarmDocsRootInput, cv as FarmDocsSidebarItem, cw as FarmDocsSocialImageConfig, cx as FarmDocsSocialImageFonts, cy as FarmDocsUserConfig, a as FarmIntegration, cz as FarmIntegrationCategory, cA as FarmIntegrationConfigContext, cB as FarmIntegrationConfigDefinition, cC as FarmIntegrationConfigInput, cD as FarmIntegrationContributedPlugin, cE as FarmIntegrationData, cF as FarmIntegrationDocumentNavigation, cG as FarmIntegrationEndpointValue, cH as FarmIntegrationEndpoints, cI as FarmIntegrationEndpointsFactory, cJ as FarmIntegrationEndpointsFactoryContext, cK as FarmIntegrationHandlerContext, cL as FarmIntegrationInputSchema, cM as FarmIntegrationLifecycleContext, cN as FarmIntegrationLifecycleHook, cO as FarmIntegrationLifecycleLogLevel, cP as FarmIntegrationLifecycleLogger, cQ as FarmIntegrationLogEvent, cR as FarmIntegrationLogPhase, cS as FarmIntegrationLogger, cT as FarmIntegrationMiddleware, cU as FarmIntegrationOrmClient, cV as FarmIntegrationOrmSchema, cW as FarmIntegrationPluginOwner, cX as FarmIntegrationProvider, cY as FarmIntegrationProviderComponentReference, cZ as FarmIntegrationProviderProps, c_ as FarmIntegrationRequestContextStore, c$ as FarmIntegrationRoute, d0 as FarmIntegrationRouteArgs, d1 as FarmIntegrationRouteDb, d2 as FarmIntegrationRouteFactory, d3 as FarmIntegrationRouteHook, d4 as FarmIntegrationRouteHookContext, d5 as FarmIntegrationRouteInput, d6 as FarmIntegrationRouteInputSchemas, d7 as FarmIntegrationRouteInputSource, d8 as FarmIntegrationRouteMethod, d9 as FarmIntegrationRouteMiddleware, da as FarmIntegrationRouteParamValue, db as FarmIntegrationRouteParams, dc as FarmIntegrationRouteStorageArgs, dd as FarmIntegrationRoutesFactory, de as FarmIntegrationRoutesFactoryContext, df as FarmIntegrationSchema, dg as FarmIntegrationSchemaConstraint, dh as FarmIntegrationSchemaField, di as FarmIntegrationSchemaFieldType, dj as FarmIntegrationSchemaModel, dk as FarmIntegrationSchemaModelExtension, dl as FarmIntegrationSchemaModelOverride, dm as FarmIntegrationSchemaReference, dn as FarmIntegrationSession, dp as FarmIntegrationSlot, dq as FarmIntegrationStandardValidationResult, dr as FarmIntegrationValidationErrorLike, ds as FarmIntegrationValidationIssue, dt as FarmIntegrationValidationPathSegment, du as FarmIntegrationValidationResult, dv as FarmIntegrationsUserConfig, aN as FarmIsolatedClientHydrationMode, dw as FarmLayerConfig, dx as FarmMCPAuthorization, dy as FarmMCPAuthorizeContext, dz as FarmMCPConfig, dA as FarmMCPEndpoint, dB as FarmMCPEndpointTool, dC as FarmMCPExecuteContext, dD as FarmMCPOAuthConfig, dE as FarmMCPPrompt, dF as FarmMCPPromptMessage, dG as FarmMCPResource, dH as FarmMCPResourceContent, dI as FarmMCPResourceContext, dJ as FarmMCPResourceListing, dK as FarmMCPServer, dL as FarmMCPServerFunction, bq as FarmMCPServerRegistration, dM as FarmMCPStandaloneTool, dN as FarmMCPTool, dO as FarmMCPToolDefinition, aO as FarmMCPUserConfig, dP as FarmMarkdownMirrorTarget, br as FarmMarkdownResolvedConfig, dQ as FarmMarkdownResolvedRoute, dR as FarmMarkdownRouteInput, dS as FarmMarkdownUserConfig, m as FarmMdxComponent, g as FarmMdxComponents, h as FarmMdxResolvedConfig, n as FarmMdxUserConfig, bj as FarmMiddlewareConfig, aP as FarmMigrationCommand, aQ as FarmMigrationsConfig, aR as FarmMigrationsUserConfig, dT as FarmPageFormAction, dU as FarmPageFormField, dV as FarmPageFormOption, dW as FarmPageFormSubmit, dX as FarmPerformanceConfig, Z as FarmPluginBuildHooks, _ as FarmPluginClientConfig, u as FarmPluginContext, $ as FarmPluginDatabase, a0 as FarmPluginDefinition, a1 as FarmPluginDevHooks, a2 as FarmPluginDiscoveredRoute, dY as FarmPluginFactory, a3 as FarmPluginIntegrationContext, a4 as FarmPluginLifecycle, dZ as FarmPluginOptionsError, d_ as FarmPluginOptionsIssue, d$ as FarmPluginOptionsSchema, a5 as FarmPluginRenderHooks, a6 as FarmPluginRouteRuntimePayload, a7 as FarmPluginRouterHooks, a8 as FarmPluginRuntimeAfterEvent, a9 as FarmPluginRuntimeBaseEvent, aa as FarmPluginRuntimeBeforeEvent, ab as FarmPluginRuntimeCloseEvent, ac as FarmPluginRuntimeContextEvent, ad as FarmPluginRuntimeEndpoint, ae as FarmPluginRuntimeEndpointEvent, af as FarmPluginRuntimeErrorEvent, ag as FarmPluginRuntimeHooks, ah as FarmPluginRuntimeKind, ai as FarmPluginRuntimeRequestHandler, aj as FarmPluginRuntimeRequestOptions, ak as FarmPluginRuntimeSession, al as FarmPluginRuntimeStartEvent, am as FarmPluginSetupContext, an as FarmPluginStateContext, e0 as FarmPreloadMode, e1 as FarmPreloadUserConfig, D as FarmRedirectSignal, E as FarmRedirectStatus, s as FarmRequest, ao as FarmRequestPluginContext, ap as FarmRequestStore, t as FarmResponse, C as FarmRouteMaxDuration, A as FarmRouteRegions, e2 as FarmRouteRenderingMode, e3 as FarmRouteRule, e4 as FarmRouteRuleCors, e5 as FarmRouteRuleRedirect, e6 as FarmRouteRuleRenderMode, e7 as FarmRouteRules, z as FarmRouteRuntime, f as FarmRouteRuntimeConfig, e8 as FarmRouteRuntimeEntryKind, e9 as FarmRouteRuntimeManifest, ea as FarmRouteRuntimeManifestEntry, aq as FarmRuntimeShutdownError, x as FarmSearchParams, eb as FarmSecurityConfig, ec as FarmServerComponentsConfig, bn as FarmServerComponentsMode, ed as FarmServerComponentsOptions, ee as FarmTypedIntegrationRoute, p as FarmUserConfig, aS as GenerateStaticParams, ar as HMRUpdatePayload, ef as HeaderConfig, eg as I18nConfig, eh as ImageConfig, ei as InferFarmIntegrationOrmClient, ej as InferFarmIntegrationOrmField, ek as InferFarmIntegrationOrmFields, el as InferFarmIntegrationOrmSchema, em as InferPluginOptionsInput, en as InferPluginOptionsOutput, eo as IntegrationOriginPolicy, ep as IntegrationOriginRejection, eq as IntegrationOriginResult, er as IntegrationOrmModelNames, aT as Layout, aU as LayoutMetadataProps, aV as LayoutModule, L as LayoutProps, aW as Loading, aX as LoadingProps, es as MemoryRateLimitStorageOptions, M as Metadata, aY as MetadataJsonLd, aZ as MetadataProps, a_ as MetadataRobots, a$ as MetadataRobotsDirectives, et as MetadataRoute, eu as MetadataRouteContext, ev as MiddlewareChain, ew as MiddlewareConfig, bm as MiddlewareContext, as as MiddlewareDiscoveredPayload, ex as MiddlewareFunction, b0 as MiddlewareProps, ey as MiddlewareResult, ez as MiddlewareStore, eA as NextFunction, at as NitroBuildLifecyclePayload, b1 as NitroPreset, b2 as Page, w as PageProps, b3 as PagePropsWithMiddleware, b4 as PageRouteParams, P as ParsedRoute, y as PluginContextProps, au as PluginManager, av as PluginRequestContext, eB as RateLimitConfig, eC as RateLimitIncrementResult, eD as RateLimitStatus, eE as RateLimitStorage, bi as ReadonlyMiddlewareStore, eF as RedirectConfig, aw as RenderLifecyclePayload, eG as RequestMiddleware, eH as RequestMiddlewareContext, eI as ResolveMarkdownMirrorTargetOptions, bx as ResolvedFarmAPIConfig, bA as ResolvedFarmAuthConfig, bo as ResolvedFarmConfig, eJ as ResolvedFarmCspConfig, eK as ResolvedFarmDeployConfig, bz as ResolvedFarmDevIndicatorsConfig, ax as ResolvedFarmDevtoolsConfig, eL as ResolvedFarmMCPConfig, b5 as ResolvedFarmMigrationsConfig, bB as ResolvedFarmPerformanceConfig, eM as ResolvedFarmPreloadConfig, bv as ResolvedFarmRouteRuntimeConfig, bC as ResolvedFarmSecurityConfig, eN as ResolvedSchemaModel, eO as RewriteConfig, ay as RouteDiscoveredPayload, az as RouteMatchPayload, aA as RouteMatchResultPayload, i as RouteModule, q as RouteSegment, aB as RoutesGeneratedPayload, b6 as SSGCollectionResult, b7 as SSGPage, b8 as ServerAction, aC as ShutdownPayload, b9 as StaticPathParams, ba as StaticPathPrimitive, bb as StaticRouteParams, bc as ThemeColorDescriptor, bd as Viewport, eP as _getFarmMarkdownPageCheckToken, eQ as _isFarmMarkdownPageCheck, eR as _readFarmRenderedHtml, eS as applyMarkdownNegotiationHeaders, eT as collectSchemaModels, k as createFarmMarkdownErrorBody, eU as createFarmRouteRuntimeKey, eV as createIntegrationOrm, eW as createIntegrationRoute, eX as createMarkdownMirrorResponse, eY as defineIntegration, eZ as defineIntegrationSchema, aD as definePlugin, e_ as describeIntegrationOriginRejection, e$ as describeSchemaReference, f0 as dispatchIntegrationRequest, f1 as dispatchIntegrationRequests, f2 as escapeSqlString, f3 as extractFarmPageActions, f4 as farmAcceptQuality, f5 as farmIntegrationSchemaToOrmSchema, l as farmRequestWantsMarkdown, f6 as farmRouteRuleMatches, f7 as forwardIntegrationSetCookies, f8 as generateFarmDevIndicatorsClientRuntime, f9 as generateSqlStatements, fa as getDeployTargetForPreset, fb as getFarmAPIBaseURL, fc as getFarmIntegrationPluginOwner, fd as getFarmIntegrationPluginServerRuntime, fe as getFarmMarkdownAlternatePath, ff as getFarmMarkdownMirrorPath, G as getFarmRedirectError, fg as getFarmRouteRuntimeConfig, fh as getIntegrationDocumentNavigationMatchers, fi as getIntegrationProviders, fj as getIntegrationSchemas, fk as getPresetForDeployTarget, fl as getRegisteredIntegrationAPIManifest, fm as getRegisteredIntegrationRuntime, fn as getRegisteredIntegrationSchemas, fo as getRegisteredIntegrations, fp as getSqlColumnType, fq as getSqlDefaultExpression, fr as hasFarmRouteRuntimeControls, fs as htmlToMarkdown, ft as integrationMiddlewareMayHandlePath, fu as integrationRoute, fv as isFarmIntegration, fw as isFarmIntegrationProviderComponentReference, fx as isFarmMarkdownMirrorExposed, H as isFarmNotFoundError, I as isFarmRedirectError, fy as isNullableField, O as loadConfig, fz as matchIntegrationRoute, fA as matchRegisteredIntegrationRoute, fB as matchesFarmMarkdownRoutePattern, fC as mergeFarmRouteRuntimeConfigs, fD as normalizeDeployTarget, fE as normalizeFarmAPIBasePath, fF as normalizeFarmAPIConfig, fG as normalizeFarmRouteRuntimeConfig, fH as normalizeRouteRules, J as notFound, K as permanentRedirect, fI as quoteSqlIdentifier, N as redirect, bu as registerFarmMCPServer, fJ as renderSqlSchemaFile, fK as requestAcceptsMarkdown, Q as resolveConfig, S as resolveDeployConfig, fL as resolveDeployOutputPath, fM as resolveFarmAPIConfig, fN as resolveFarmAPIRequestURL, fO as resolveFarmDevIndicatorsConfig, aE as resolveFarmDevtoolsConfig, r as resolveFarmMdxComponentsModulePath, fP as resolveFarmRouteRuleRuntimeConfig, fQ as resolveFarmRouteRuntimeConfig, fR as resolveIntegrationAllowedOrigins, fS as resolveIntegrationOrmRuntimeClient, fT as resolveIntegrationPlugins, fU as resolveMarkdownConfig, fV as resolveMarkdownMirrorTarget, o as resolveMdxConfig, fW as resolveMigrationsConfig, fX as resolveSchemaModels, fY as routeRulesToHeaders, fZ as routeRulesToNitroRouteRules, f_ as routeRulesToRedirects, f$ as toCamelCase, g0 as toPascalCase, g1 as toSnakeCase, g2 as validateIntegrationRequestOrigin } from './client-plugins.d-BgPUYPc9.js';
+export { F as FarmAppManifest, a as FarmAppManifestServer, b as FarmAppManifestTool } from './app-manifest.d-poayV4lq.js';
+export { FarmRenderer, FarmRendererCapabilities, FarmRendererCapabilitiesInput, FarmRendererRuntime, FarmRendererStreamingCapabilities, FarmRendererStreamingPrimitives, REACT_RENDERER, defineRenderer } from './renderer.js';
+export { f as fileExists, g as globFiles, l as logger, m as matchRoute, a as matchRouteParts, b as matchRoutePrefix, c as matchRoutePrefixParts, p as parseRoutePath, d as parseSearchParams, r as resolveAppPath, s as segmentsToPattern, e as splitRoutePath, t as toPosixPath, h as toRootRelativeUrlPath, i as toViteModuleId } from './utils.d-CjyE-npA.js';
+export { _collectFarmStorageModules, _registerFarmStorageModules, createFarmStorage, createStorageClient, databaseStorage, defineStorageClient, disposeStorage, driverStorage, getStorage, initStorage, libsqlStorage, localStorage, memoryStorage, mongodbStorage, mysql2Storage, mysqlStorage, netlifyBlobsStorage, pgStorage, pgliteStorage, planetscaleStorage, postgresStorage, redisStorage, resolveStorageRuntimeClient, s3Storage, sqliteStorage, upstashStorage, vercelBlobStorage, vercelKVStorage } from './storage.js';
+import { FarmSchemaField, FarmSchema, FarmSchemaReference } from './schema.js';
+export { FarmSchemaConfig, FarmSchemaConstraint, FarmSchemaFieldType, FarmSchemaModel, FarmSchemaModelExtension, FarmSchemaModelOverride, defineSchema } from './schema.js';
+export { F as FarmIntegrationAPI, e as FarmIntegrationAPIBodyFormat, f as FarmIntegrationAPIMethod, g as FarmIntegrationAPIOperation, h as FarmIntegrationAPIResponseFormat, i as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes, j as PluginAPIRouter, P as PluginLocalAPI, a as PluginLocalAPIEndpoint, b as PluginRoutes, c as PluginRoutesFactory, R as RouteDefinition, k as RouteFactory, l as RouteInputSchemas, m as RouteJSON, d as RouteMethod, n as RouteOptions, o as RoutePathParams, p as api, q as createRouteFactory, r as defineIntegrationAPI, s as defineIntegrationAPIOperation, t as endpoint, u as resolvePluginRoutes } from './route.d-DBTEqifW.js';
+export { c as createFarmApp } from './app.d-D4Dn03E3.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+export { ComponentType, FC, PropsWithChildren, ReactElement, ReactNode } from 'react';
+export { g as getCurrentRequest } from './request.d-X7Q1vmGF.js';
+export { F as FarmIslandStrategy } from './island.d-CfGru1MO.js';
+import { R as ResolvedFarmLayer } from './layers.d-CcS42OGR.js';
+export { a as FarmLayerEntry, g as getFarmAppDirectories, e as getFarmLayerAliases, f as getFarmSourceRoots, r as resolveFarmLayers } from './layers.d-CcS42OGR.js';
+import { ViteDevServer } from 'vite';
+export { createEnvPlugin, createHeadersPlugin, createLoggerPlugin, createRedirectsPlugin, createRewritesPlugin } from './server-plugins.js';
+export { createCompressionPlugin } from './internal/compression-runtime.js';
+export { A as AnyEndpointMiddleware, D as DELETE, g as EndpointErrorContracts, h as EndpointErrorDefinition, j as EndpointErrorDefinitions, k as EndpointErrorHandler, l as EndpointErrorSchema, m as EndpointFail, f as EndpointFailure, n as EndpointHandler, o as EndpointInvalidationContext, q as EndpointInvalidationTarget, r as EndpointInvalidations, E as EndpointMCPMetadata, a as EndpointMCPOptions, s as EndpointMiddleware, t as EndpointMiddlewareContext, c as EndpointMiddlewareResult, b as EndpointOpenAPIMetadata, u as EndpointOptions, v as EndpointParamValue, w as EndpointParams, F as FarmAPIStream, x as FarmStreamResponse, G as GET, H as HEAD, I as InferEndpointMiddlewareContext, M as MultipartField, y as MultipartSchema, z as MultipartValues, O as OPTIONS, P as PATCH, B as POST, C as PUT, Q as QUERY, T as TypedEndpoint, J as TypedFormData, K as createEndpoint, i as isEndpointFailure, L as isFarmAPIStream, N as isJSONStreamResponse, S as isMultipartSchema, U as jsonStream, V as multipart, W as readJSONStream, X as toFormData } from './endpoint.d-BgHn0lhl.js';
+export { APIRoute, APIRouteConflictError, APIRouteHandlerOptions, APIRouteManager, APIRouteManagerOptions } from './api/route-manager.js';
+export { A as APIClient, b as APIClientError, d as APIClientOptions, e as APIClientSystemError, f as APIClientWithoutIntegrationsOptions, l as APIQueryPrimitive, m as APIQueryValue, n as APIResult, o as APIRouteManifest, p as APIRouteRefMetadata, g as ApiClients, C as CacheKey, q as CacheOptions, r as CachePolicy, s as CacheScope, t as ClientHeaders, u as ClientLifecycleHooks, v as ClientOptions, w as ClientRequestEvent, x as ClientResponseEvent, F as FARM_API_ROUTE_META_SYMBOL, y as FARM_API_ROUTE_REF_SYMBOL, I as InferIntegrationOperationBody, z as InferIntegrationOperationQuery, B as InferIntegrationOperationResponse, D as IntegrationAPI, E as IntegrationClient, G as IntegrationClientAliases, H as IntegrationClientData, J as IntegrationClientError, K as IntegrationClientOptions, L as IntegrationClientRequestOptions, M as IntegrationClientRoot, N as IntegrationClients, O as IntegrationOperationResult, P as IntegrationServerClient, Q as IntegrationServerClientAliases, T as IntegrationServerClientOptions, U as IntegrationServerClientRequestOptions, V as IntegrationServerClientRoot, W as IntegrationServerRequestLike, X as InvalidateOptions, Y as InvalidateTarget, Z as OptimisticOptions, _ as OptimisticUpdate, $ as RequestEvent, a0 as ResponseEvent, a1 as RetryAttemptContext, k as RetryOptions, R as RouteAPIClient, S as ServerAPIClient, h as ServerAPIClientOptions, i as ServerAPIClientWithoutIntegrationsOptions, a2 as StatusEvent, a3 as StatusPhase, a4 as applyServerFnOptimisticUpdates, c as createAPIClient, a as createApiClients, a5 as createIntegrationApi, a6 as createIntegrationClient, a7 as createIntegrationClients, a8 as createIntegrationServerClient, a9 as createIntegrations, j as createServerAPIClient, aa as getAPIRouteRefMetadata, ab as getIntegrationAPIManifest, ac as integrationClients, ad as integrationsClient, ae as integrationsServer, af as isAPIRouteRef, ag as resolveServerFnInvalidateTargets, ah as settleServerFnOptimisticUpdates } from './api-client.d-ddQBNGtu.js';
+export { ApiRoute, FarmApiPluginOptions, farmApiPlugin, resolveFarmAPIServerBasePath } from './api.js';
+export { ArrayParserOptions, Parser, asArrayOf, asBoolean, asFloat, asInteger, asIsoDate, asIsoDateTime, asJson, asString, createParser, inferParserType } from './query/parsers.js';
+export { R as RouteParamsInput, l as loadRouteParams, p as parseRouteParams } from './params.d-BALtrRim.js';
+export { FarmQueryStateContext, LayoutPropsSafe, PagePropsSafe, QueryStateConfig, QueryStateProvider } from './query/index.js';
+export { FarmMiddlewarePluginOptions, MiddlewareManager, UnsupportedRateLimitStorageError, canonicalizeRequestPathSegments, canonicalizeRequestPathname, createContext, farmMiddlewarePlugin, getFromMiddleware, getRateLimitStatus, hasMiddlewareData, memoryRateLimitStorage, middleware, parseMiddlewareCookieHeader, serializeMiddlewareCookie, serializeMiddlewareCookieDeletion, unwrapMiddleware } from './middleware.js';
+export { _ as _runWithMiddlewareContext, a as _runWithMiddlewareData, b as applyProductionMiddlewareHeaders, c as createProductionMiddlewareRunner, g as getMiddlewareContext, d as getMiddlewareData, e as getMiddlewareValue, m as matchesMiddlewareConfig } from './production-runtime.d-C0rF7a10.js';
+export { FarmRouter, FarmRouterActiveOptions, FarmRouterBuildOptions, FarmRouterMatch, FarmRouterParams, FarmRouterPathParam, FarmRouterPathParams, FarmRouterPrimitiveParam, FarmRouterQueryValue, FarmRouterRoute, FarmRouterRouteInput, buildFarmRoutePath, createFarmRouter, isFarmRouteActive, matchFarmRoute } from './router.js';
+export { CreateRouteOptions, InferProgrammaticRouteData, InferProgrammaticRouteSchema, ProgrammaticApiRoute, ProgrammaticApiRouteOptions, ProgrammaticLayoutRoute, ProgrammaticPageRoute, ProgrammaticRedirectRoute, ProgrammaticRouteAction, ProgrammaticRouteActionContract, ProgrammaticRouteActions, ProgrammaticRouteBuilder, ProgrammaticRouteComponentProps, ProgrammaticRouteContext, ProgrammaticRouteDataCacheContext, ProgrammaticRouteDataCacheKeys, ProgrammaticRouteDataContext, ProgrammaticRouteDataHooks, ProgrammaticRouteDataStaleTime, ProgrammaticRouteDefaultAction, ProgrammaticRouteDefinition, ProgrammaticRouteErrorComponentProps, ProgrammaticRouteFactory, ProgrammaticRouteGuard, ProgrammaticRouteGuardContext, ProgrammaticRouteManifest, ProgrammaticRouteMaybePromise, ProgrammaticRouteMethod, ProgrammaticRouteParamsFallback, ProgrammaticRoutePendingComponentProps, ProgrammaticRoutePrimitive, ProgrammaticRouteRenderMode, ProgrammaticRouteSchema, ProgrammaticRouteSearchClientOptions, ProgrammaticRouteSearchConfig, ProgrammaticRouteSearchFallback, ProgrammaticRouteSearchOptions, ProgrammaticRouteWithActions, ProgrammaticStaticPath, ProgrammaticStaticPathParams, ProgrammaticStaticPaths, createLayoutModuleFromProgrammaticLayout, createProgrammaticRouteModuleId, createRoute, createRouteModuleFromProgrammaticPage, defineRoutes, getProgrammaticRouteManifest, isProgrammaticRouteManifest, isProgrammaticRoutesFileName, layout, page, parseProgrammaticRouteModuleId, parseProgrammaticRoutePath, routesBuilder, scanProgrammaticPagePaths } from './routes.js';
+export { FarmDocsAPIHandler, FarmDocsAPIOptions, FarmDocsAPIRouteHandlers, FarmDocsAdapterHandlerOptions, FarmDocsCloudIntegration, FarmDocsCloudRouteOptions, FarmDocsCloudServer, FarmDocsHandlerOptions, FarmDocsPage, LoadedFarmDocsPage, createDocsAPI, createFarmDocsAPIHandler, createFarmDocsAdapterHandler, createFarmDocsHandler, discoverFarmDocsPages, getFarmDocsConfigModuleRoot, getFarmDocsDocumentNavigationMatchers, getFarmDocsRouteTypeEntries, hasFarmDocsRuntimeAdapter, isFarmDocsAPIRequest, isFarmDocsRequest, loadFarmDocsPage, resolveFarmDocsContentDir } from './docs.js';
+export { createFarmMarkdownRouteModuleFromFile, loadFarmMdxComponents } from './app-markdown.js';
+export { F as FarmAPIEvent, a as FarmAgentEvent, b as FarmAgentIdentity, c as FarmBuildEvent, d as FarmCacheEvent, e as FarmErrorEvent, f as FarmEvent, g as FarmEventBase, h as FarmEventHandler, i as FarmEventInput, j as FarmEventLevel, k as FarmEventSubscriptionOptions, l as FarmEventType, m as FarmIntegrationEvent, n as FarmMCPEvent, o as FarmMiddlewareEvent, p as FarmObservabilityUserConfig, q as FarmPPREvent, r as FarmPluginEvent, s as FarmRenderEvent, t as FarmRequestEvent, u as FarmRequestSpanOptions, v as FarmResolvedObservabilityConfig, w as FarmResolvedTracingConfig, x as FarmRouteEvent, y as FarmServerEvent, z as FarmSpanOptions, A as FarmStorageEvent, B as FarmTraceContext, C as FarmTraceSpanKind, D as FarmTracingConfig, E as FarmTracingUserConfig, G as classifyFarmAgent, H as configureFarmObservability, I as configureFarmTracing, J as emitFarmEvent, K as getFarmTraceContext, L as normalizeFarmObservabilityConfig, M as normalizeFarmTracingConfig, N as onFarmEvent, O as resetFarmObservability, P as runWithFarmRequestSpan, Q as runWithFarmSpan } from './observability.d-B2363jB6.js';
+import { FarmCronJob } from './cron.js';
+export { DEFAULT_FARM_CRON_SECRET_ENV, FARM_CRON_MANIFEST, FARM_CRON_NAME_SEGMENT_PATTERN, FARM_CRON_SIGNATURE_HEADER, FarmCronCloudflareConfig, FarmCronConfig, FarmCronContext, FarmCronInputValue, FarmCronJobConfig, FarmCronProvider, FarmCronResolvedConfig, FarmCronRouteOptions, FarmCronSchedule, FarmCronUserConfig, PreparedFarmCron, applyFarmCronVercelCrons, authorizeCronRequest, createFarmCronCloudflareConfig, createFarmCronCloudflareTriggers, createFarmCronManifest, createFarmCronVercelCrons, cronRoute, farmCronSignature, isCronRequestAuthorized, mergeScheduledTasks, normalizeCronExpression, prepareFarmCronForNitro, resolveCronConfig } from './cron.js';
+export { D as DEFAULT_FARM_WORKFLOW_DIRS, a as DEFAULT_FARM_WORKFLOW_ROUTE, b as DEFAULT_FARM_WORKFLOW_SECRET_ENV, d as FarmCronDefinition, e as FarmDiscoveredWorkflow, f as FarmServerConfig, g as FarmServerDuration, h as FarmServerHealthConfig, i as FarmWorkflowDefinition, j as FarmWorkflowHTTPHandlerOptions, k as FarmWorkflowLogger, l as FarmWorkflowRunContext, m as FarmWorkflowSchedule, F as FarmWorkflowsResolvedConfig, n as FarmWorkflowsUserConfig, P as PreparedFarmWorkflows, R as ResolvedFarmServerConfig, o as ResolvedFarmServerHealthConfig, p as applyFarmWorkflowVercelCrons, q as createFarmWorkflowRequestHandler, r as createFarmWorkflowVercelCrons, s as defineCron, t as defineTask, u as defineWorkflow, v as discoverFarmWorkflows, w as prepareFarmWorkflowsForNitro, x as resolveWorkflowsConfig, y as runFarmWorkflowModule } from './workflows.d-CRMzQZ3k.js';
+export { BundledFarmEnv, EnvParser, EnvSchema, EnvShape, FarmEnvConfig, FarmEnvRuntimeType, FarmEnvTypes, FarmPublicEnv, FarmServerEnv, FarmTypedEnv, InferEnv, InferEnvParser, InferEnvShape, ResolvedFarmEnv, createBundledEnv, env, getEnv, getPublicEnv, getResolvedEnv, publicEnv, resolveEnv, serverEnv, setEnv } from './env.js';
+export { GenerateEnvTypesOptions, createEnvTypeDeclarations, generateEnvTypes } from './env-types.js';
+export { resolveFarmThemeConfig } from './theme/index.js';
+export { b as FarmResolvedTheme, d as FarmThemeConfig, a as FarmThemePreference, F as FarmThemeSnapshot, R as ResolvedFarmThemeConfig } from './types.d-DQnyD3VD.js';
+export { FarmEnvironment, FarmEnvironmentError, FarmIsomorphicFnOptions, createClientOnlyFn, createIsomorphicFn, createServerOnlyFn } from './environment.js';
+export { FarmFont, FarmFontDisplay, FarmFontOptions, FarmFontSource, FarmLayoutFontModule, FarmLayoutFonts, LocalFontOptions, RemoteFontOptions, RemoteFontSource, defineLayoutFonts, localFont, remoteFont, resolveFarmLayoutFonts } from './font.js';
+import { R as ResolvedFarmI18nConfig } from './types.d-C41ePjvP.js';
+export { h as FarmI18nCookieConfig, i as FarmI18nDetectionSignal, j as FarmI18nDirection, g as FarmI18nRouting, k as FarmI18nUserConfig } from './types.d-C41ePjvP.js';
+export { AnyServerFnMiddleware, FARM_SERVER_FN_SYMBOL, InferServerFnError, InferServerFnSchemaInput, InferServerFnSchemaOutput, ServerFn, ServerFnContext, ServerFnDeclaredError, ServerFnError, ServerFnErrorDefinition, ServerFnErrorDefinitions, ServerFnErrorHandler, ServerFnErrorSchema, ServerFnFormInput, ServerFnHandler, ServerFnHandlerContext, ServerFnInvalidationContext, ServerFnInvalidations, ServerFnMCPMetadata, ServerFnMiddleware, ServerFnMiddlewareContext, ServerFnMiddlewareContinuation, ServerFnMiddlewareHandler, ServerFnMiddlewareHandlerContext, ServerFnMiddlewareNext, ServerFnMiddlewareOptions, ServerFnOptions, ServerFnOutputOptions, ServerFnSchema, ServerFunctionDescriptor, ServerFunctionInvocation, _attachServerFunctionDescriptor, _describeServerFunction, _invokeServerFunction, _parseServerFnSchema, _runServerFunctionForCaller, createServerFn, createServerFunctionDescriptor, createServerMiddleware } from './server-fn.js';
+export { RouteActionTarget, ServerFnActionStatus, ServerFnOptimisticContext, ServerFnSubmit, UseActionFormProps, UseActionReturn, UseServerFnOptions, UseServerFnReturn, useAction, useServerFn } from './server-fn-client.js';
+export { FARM_SERVER_QUERY_SYMBOL, ServerQuery, ServerQueryKey, ServerQueryOptions, ServerQueryOutputOptions, ServerQueryStaleTime, createServerQuery } from './server-query.js';
+export { UseServerQueryOptions, UseServerQueryResult, useServerQuery } from './server-query-client.js';
+export { DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT, FarmServerActionsConfig, PreparedServerActionRequest, ResolvedFarmServerActionsConfig, SanitizedServerActionError, ServerActionRequestError, ServerActionRequestKind, createServerActionRequestErrorResponse, getServerActionExecutionContext, getServerActionInvalidations, getServerActionSignal, prepareServerActionRequest, resolveServerActionsConfig, runWithServerActionRequest, sanitizeServerActionError, validateServerActionRequest } from './server-action-security.js';
+export { FARM_DEPLOYMENT_COOKIE, FARM_DEPLOYMENT_ID_HEADER, FARM_DEPLOYMENT_MISMATCH_CODE, FARM_DEPLOYMENT_MISMATCH_HEADER, FARM_DEPLOYMENT_MISMATCH_STATUS, FarmDeploymentMismatch, FarmDeploymentMismatchError, FarmDeploymentResponseOptions, FarmPresetRuntime, createFarmDeploymentCookie, createFarmDeploymentMismatchError, createFarmDeploymentMismatchResponse, createFarmDeploymentRequestHeaders, getFarmDeploymentMismatch, getFarmPresetRuntime, getFarmRequestDeploymentId, getFarmResponseDeploymentId, isFarmDeploymentMismatchResponse, normalizeFarmDeploymentId, withFarmDeploymentResponse } from './deployment.js';
+export { F as FARM_RSC_INSTALL_HINT, a as FarmServerComponentsStatus, b as build, c as findFarmAppPackageDir, d as formatFarmRscBlockingMessage, e as formatFarmRscFallbackMessage, i as inspectFarmServerComponents } from './index.d-Coow7bD4.js';
+export { a as FarmImageConfig, F as FarmImageFormat, b as FarmImageLocalPattern, c as FarmImageProvider, d as FarmImageRemotePattern, R as ResolvedFarmImageConfig } from './image-config.d-CeDgNyX4.js';
+export { G as GenerateRouteTypesOptions, g as generateRouteTypes } from './generate-route-types.d-BL2pq6xC.js';
+export { AnyMutationTarget, ClientCachePersistenceOptions, CrossTabCacheInvalidationOptions, DefaultRouteHref, DefaultRoutePath, DefaultRoutePattern, ExternalHref, FARM_CACHE_INVALIDATION_CHANNEL, FARM_CLIENT_CACHE_PERSIST_VERSION, FarmClientCacheAdapter, FarmClientCacheStorage, FetcherFormDataContext, FetcherFormProps, FetcherInputError, FetcherState, FetcherSubmit, FetcherSubmitAsync, InferMutationData, InferMutationError, InferMutationVariables, Link, LinkDefaultRoute, LinkExternalUriSchemes, LinkProps, LiveCacheInvalidationOptions, MutationAsync, MutationNetworkMode, MutationOptimisticContext, MutationStatus, MutationTrigger, PersistedEntry, PrefetchBehavior, RouteHref, RouteOptionalParamValue, RouteParamValue, RouteParams, Store, StoreApi, StoreFields, StoreKeyListener, StoreKeysListener, StoreListener, StorePatch, StoreState, StoreValueUpdater, UseFetcherOptions, UseFetcherReturn, UseMutationOptions, UseMutationReturn, clearPersistedCache, createStore, defineClientCacheAdapter, enableCrossTabCacheInvalidation, enableLiveCacheInvalidation, initConfiguredClientCachePersistence, initPersistedClientCache, storageClientCacheAdapter, useFetcher, useMutation } from './client.js';
+export { a as FarmClientCacheEntry, b as FarmClientCacheKey, F as FarmClientCacheStatus, g as getFarmClientDataCache, n as normalizeFarmClientCacheKey } from './client-cache.d-Deoqq-nM.js';
+export { UseThemeResult, useTheme } from './theme/client.js';
+export { U as UseBlockerOptions, a as UseBlockerReturn, b as UseRouterOptions, u as useBlocker, c as useNavigation, d as usePageState, e as useRouter, f as useScrollRestoration } from './router.d-crorSRiW.js';
+export { b as FarmNavigateOptions, c as FarmNavigationBlocker, F as FarmNavigationBlockerContext, d as FarmNavigationListener, e as FarmNavigationLocation, a as FarmNavigationState, f as FarmViewTransitionMode, S as SPARouter, g as getRouter, n as navigateTo, p as prefetch, h as pushState, r as readPageState, i as replaceState } from './spa-router.d-CCADbSqJ.js';
+export { F as FarmNavigationDelegate, a as FarmNavigationDelegateContext, d as delegateNavigation } from './navigation-delegate.d-aHiPI6GL.js';
+export { F as FarmChunkRecoveryOptions, i as installChunkErrorRecovery, a as isChunkLoadError } from './chunk-recovery.d-lnQFzcQP.js';
+export { b as FarmClientHydrationCompleteEvent, d as FarmClientHydrationEvent, e as FarmClientHydrationMode, f as FarmClientHydrationSession, g as FarmClientLocation, h as FarmClientNavigationAction, i as FarmClientNavigationErrorEvent, j as FarmClientNavigationEvent, k as FarmClientNavigationLoadedEvent, l as FarmClientNavigationResolvedEvent, m as FarmClientNavigationSession, n as FarmClientPerformanceEvent, a as FarmClientPlugin, o as FarmClientPluginCloseEvent, p as FarmClientPluginEnforce, q as FarmClientPluginErrorEvent, r as FarmClientPluginErrorPhase, F as FarmClientPluginManager, s as FarmClientPluginManagerOptions, t as FarmClientPluginMetadata, u as FarmClientPluginRegistration, v as FarmClientPluginRouter, w as FarmClientPluginSetupEvent, x as FarmClientPluginStateEvent, c as createClientPluginManager } from './lifecycle.d-C2aLBOwu.js';
+export { S as StaticRouteCandidateAnalysis, b as analyzeStaticRouteCandidate, d as collectSSGPages, f as findRequestBoundSourceBlockers, g as generateSSGManifest, e as getRevalidateInterval, h as hasISR, i as hasPPR, j as isSSGModule, m as matchSSGPage, p as parseRouteRenderingDirective, r as readRouteRenderingDirectiveFromFile, k as resolveRouteRenderingConfig, l as resolveRouteRenderingConfigFromFile } from './client-component.d-CQLvqLAJ.js';
+export { CacheKeyFactory, DefinedCacheKey, FarmCacheAdapter, FarmCacheEntry, FarmCacheInvalidationStreamOptions, FarmCacheInvalidationTarget, FarmCacheOptions, FarmCacheSetOptions, FarmCacheStorage, FarmCacheUserConfig, FarmClientCacheUserConfig, FarmDataCache, GetFarmCacheEntryOptions, InferCacheKeyData, PPR_SHELL_ADAPTER_TTL_SECONDS, RevalidateTagProfile, RouteDataCacheKey, StorageFarmCacheAdapterOptions, applyFarmCacheInvalidationTargets, applyFarmCacheInvalidations, configureFarmCache, createFarmCacheInvalidationStream, createFarmCacheKey, createPathCacheTag, createRouteDataCacheKey, createRouteDataCacheTag, defineCacheKey, getFarmDataCache, invalidate, invalidateRouteData, normalizeRevalidatePath, revalidatePath, revalidateTag, storageCacheAdapter, unstable_cache, updateTag } from './cache.js';
+export { Deferred, DeferredDataError, DeferredDataResponseOptions, DeferredRecord, DeferredSettlement, DeferredSettlements, FARM_DEFERRED_BRAND, FARM_DEFERRED_CONTENT_TYPE, FARM_DEFERRED_ERROR_CODE, PreparedDeferredData, createDeferredDataResponse, defer, isDeferred, prepareDeferredData, readDeferredDataResponse, reviveDeferredData, snapshotDeferredData } from './deferred.js';
+export { AfterCallback, FarmAfterPlatformContext, _runWithAfterNodeResponse, _runWithAfterRequest, _withAfterNodeMiddleware, after } from './after.js';
+export { usePathname, useSearchParams } from './navigation.js';
+export { ReadonlyHeaders, ReadonlyRequestCookies, RequestCookie, cookies, getCspNonce, headers } from './headers.js';
+export { A as APIRouteMatch, a as APIRouteParamValue, b as APIRouteParams, m as matchAPIRoute } from './route-pattern.d-CVsVbq5n.js';
+export { A as API_ROUTE_METHODS, g as getAllowedAPIRouteMethods, i as invokeAPIRouteEndpoint, a as isWebResponse, n as normalizeRouteResponse, r as resolveAPIRouteEndpoint } from './runtime.d-CCsjTZJW.js';
+export { BuiltinDriverName, BuiltinDriverOptions, Driver, Storage, StorageMeta, StorageValue, TransactionOptions } from 'unstorage';
+export { ConnectorName, ConnectorOptions, Database } from 'db0';
+export { D as DirectiveRenderingConfig, a as RouteRenderingConfig, b as RouteRenderingDynamic, R as RouteRenderingOptions } from './route-rendering.d-BUr3Jp8S.js';
+export { FARM_MARKDOWN_ANONYMOUS_CLIENT_ADDRESS, FarmMarkdownPageModuleInput, FarmMarkdownPageSource, createFarmMarkdownRouteModule, createFarmMarkdownSourceResponse, createMarkdownMetadata, isFarmMarkdownPageFile, isFarmMarkdownPublicSourceResponse, normalizeFarmMarkdownRoutePath, parseMarkdownFrontmatter, titleFromMarkdown } from './internal/app-markdown-runtime.js';
+export { F as FARM_SERVER_FN_FAILURE_SYMBOL, S as SerializedServerFnFailure, b as ServerActionError, a as ServerFnFailure, c as createServerFnTransportError, i as isServerFnFailure } from './server-fn-error.d-DrcH9cc1.js';
+export { F as FarmServerQueryActionInvocation, S as ServerQueryFetchOptions, b as beginFarmServerQueryAction, c as completeFarmServerQueryAction, f as fetchServerQuery, p as prefetchServerQuery, s as shouldApplyFarmServerQueryActionResult } from './server-query-runtime.d-DXRNhX_3.js';
+export { e as FarmStorageBuiltinDriverConfig, b as FarmStorageClient, a as FarmStorageClientConfig, f as FarmStorageConfigObject, g as FarmStorageCustomDriverConfig, c as FarmStorageDatabaseConfig, h as FarmStorageDatabaseDriverName, d as FarmStorageLocalDriverConfig, i as FarmStorageMountConfig, j as FarmStorageMounts, k as FarmStorageRuntimeClient, F as FarmStorageUserConfig } from './types.d-BnIqOn9w.js';
+export { defineConfig, defineFarmConfig } from './config.js';
+export { getTheme, setTheme, toggleTheme } from './theme/runtime.js';
+import 'http';
+import '@farming-labs/orm';
+import '@farming-labs/docs';
+import './config.d-qt-mE8O5.js';
+import './agent-mcp.d-DOJCBSh9.js';
+import './render-plan.d-BxeITFT1.js';
+import './runtime.d-BtL3PCL3.js';
+import './resolver.d-BHyZgpa7.js';
+import 'rolldown/utils';
+import 'rolldown';
+import '@opentelemetry/api';
+import './production-vite.d-BQFAlG7n.js';
+import 'node:http';
+
+/**
+ * Reject a list field before a scalar-only schema target can silently change
+ * its value shape. Targets that genuinely preserve arrays do not call this.
+ */
+declare function assertNoSchemaListField(field: Pick<FarmSchemaField, "list">, fieldPath: string, target: string): void;
+
+/**
+ * Columns an owner adds to a table it does not own: `extend` on a model the
+ * owner marks `external` (or does not claim). The app creates the table; the
+ * owner only asks for these columns, and only an app that allows it gets them.
+ */
+type FarmSchemaExtension = {
+    /** The owner's migrate name, such as `loyalty`. */
+    owner: string;
+    /** The owner's name for the model, such as `user`. */
+    modelKey: string;
+    /** The real table, after the app's renames, such as `members_auth`. */
+    table: string;
+    fields: Array<{
+        fieldKey: string;
+        field: ResolvedSchemaField;
+    }>;
+};
+/**
+ * The extensions in an owner's schema. Throws, naming the column, for a column
+ * Farm cannot add safely to a table that may already hold rows.
+ */
+declare function collectSchemaExtensions(owner: string, schema: FarmSchema, models?: readonly string[]): FarmSchemaExtension[];
+/** Whether the app allows an owner to add columns to this table. */
+declare function isSchemaExtensionAllowed(allowExtend: Record<string, readonly string[]> | undefined, extension: Pick<FarmSchemaExtension, "owner" | "modelKey" | "table">): boolean;
+
+/** The subset of a database client this needs: run a statement, read a result. */
+type FarmSchemaExecutor = {
+    /** Run a statement that returns nothing. */
+    execute(sql: string): Promise<void>;
+    /** Run a query and return its rows. */
+    query(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;
+};
+type FarmSchemaDrift = {
+    table: string;
+    /** Declared in the schema but absent from the table. */
+    missingColumns: string[];
+    /** Present in the table but not declared. Reported, never dropped. */
+    extraColumns: string[];
+    /** Columns whose stored definition differs from the schema. */
+    changedColumns: FarmSchemaColumnDrift[];
+    /** Declared indexes that are absent from the table. */
+    missingIndexes: FarmSchemaIndexDefinition[];
+    /** Stored indexes that are not declared by the schema. */
+    extraIndexes: FarmSchemaIndexDefinition[];
+    /** Declared foreign keys that are absent from the table. */
+    missingReferences: FarmSchemaReferenceDefinition[];
+    /** Stored foreign keys that are not declared by the schema. */
+    extraReferences: FarmSchemaReferenceDefinition[];
+};
+type FarmSchemaColumnDefinition = {
+    type: string;
+    nullable: boolean;
+    default: string | null;
+    primaryKey: boolean;
+};
+type FarmSchemaColumnDrift = {
+    column: string;
+    differences: Array<"type" | "nullability" | "default" | "primaryKey">;
+    expected: FarmSchemaColumnDefinition;
+    actual: FarmSchemaColumnDefinition;
+};
+type FarmSchemaIndexDefinition = {
+    name: string;
+    columns: string[];
+    unique: boolean;
+};
+type FarmSchemaReferenceDefinition = {
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+    onDelete: "cascade" | "restrict" | "setNull" | "noAction";
+};
+type FarmSchemaMigratePlan = {
+    dialect: FarmSqlDialect;
+    /** Statements for tables that do not exist yet. */
+    statements: FarmSqlStatement[];
+    /** Tables that exist and already match the schema. */
+    upToDate: string[];
+    /**
+     * Additions to tables that exist: columns that can join a table with rows
+     * (nullable, or with a default the database can write) and non-unique
+     * indexes. Applied with the rest of the plan. Anything else stays in drift.
+     */
+    upgrades?: Array<FarmSqlStatement & {
+        table: string;
+    }>;
+    /** Tables that exist but differ in ways Farm will not change on its own. */
+    drift: FarmSchemaDrift[];
+    /**
+     * Foreign keys to other owners' tables that an existing table does not
+     * have yet. Never added automatically: they need the app's approval.
+     */
+    addableForeignKeys?: FarmSchemaAddableForeignKey[];
+};
+type FarmSchemaAddableForeignKey = {
+    modelKey: string;
+    table: string;
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+    onDelete: FarmSchemaReferenceDefinition["onDelete"];
+};
+/**
+ * Compare resolved models against the live database and plan what to create.
+ *
+ * Creation is derivable from the schema alone, so it is safe to emit. Changing
+ * an existing table is not: a rename and a drop-plus-add look identical here,
+ * and one of them destroys data. Differences are reported for a human instead.
+ */
+declare function planSchemaMigration(models: readonly CollectedSchemaModel[], dialect: FarmSqlDialect, executor: FarmSchemaExecutor): Promise<FarmSchemaMigratePlan>;
+/** A table's columns as the database reports them, normalized per dialect. */
+type FarmSchemaTableDescription = {
+    columns: Array<{
+        name: string;
+        type: string;
+        nullable: boolean;
+        primaryKey: boolean;
+    }>;
+};
+/**
+ * Read any table, owned by Farm or not, or undefined when it does not exist.
+ * Used to check references to tables the app or a library created. On
+ * Postgres and MySQL a dotted name that is not itself a table, such as
+ * Supabase's `auth.users`, is read as `schema.table`, and on Postgres an
+ * unqualified name is found through the search path.
+ */
+declare function describeSchemaTable(executor: FarmSchemaExecutor, dialect: FarmSqlDialect, table: string): Promise<FarmSchemaTableDescription | undefined>;
+type FarmSchemaMigrateResult = {
+    applied: string[];
+    skipped: FarmSchemaDrift[];
+};
+/**
+ * Run the plan's create statements. Drift is never applied: a plan that reports
+ * differences leaves those tables untouched and says so.
+ */
+declare function applySchemaMigration(plan: FarmSchemaMigratePlan, executor: FarmSchemaExecutor): Promise<FarmSchemaMigrateResult>;
+/**
+ * Column type families a foreign key can join across. Same family is fine
+ * (text and varchar, integer and bigint); different families need a cast to
+ * join and can never carry a foreign key (text and uuid, text and integer).
+ */
+/** @internal */
+declare function columnTypeFamily(type: string): string | undefined;
+type FarmSchemaExtensionStatement = FarmSqlStatement & {
+    extension: FarmSchemaExtension;
+    fieldKey: string;
+    column: string;
+};
+type FarmSchemaExtensionPlan = {
+    /** `ALTER TABLE … ADD COLUMN` for each column the table does not have yet. */
+    statements: FarmSchemaExtensionStatement[];
+    /** Columns already there, as `table.column`. */
+    present: string[];
+    /** Extensions whose table does not exist, so nothing can be added yet. */
+    missingTables: FarmSchemaExtension[];
+    /** Columns that exist with a type the extension does not expect. Left alone. */
+    conflicts: Array<{
+        extension: FarmSchemaExtension;
+        column: string;
+        expected: string;
+        actual: string;
+    }>;
+    /** Columns this database cannot add as declared. */
+    unsupported: Array<{
+        extension: FarmSchemaExtension;
+        column: string;
+        reason: string;
+    }>;
+};
+/**
+ * Plan the columns owners add to tables they do not own. Only additions:
+ * a column that exists is never altered, whatever its definition.
+ */
+declare function planSchemaExtensions(extensions: readonly FarmSchemaExtension[], dialect: FarmSqlDialect, executor: FarmSchemaExecutor): Promise<FarmSchemaExtensionPlan>;
+/** Render a plan as a reviewable SQL file. */
+declare function formatSchemaMigration(plan: FarmSchemaMigratePlan, owner: string, options?: {
+    addsColumns?: boolean;
+}): string;
+/** Human-readable summary of tables that exist but no longer match the schema. */
+declare function describeSchemaDrift(drift: readonly FarmSchemaDrift[]): string;
+/**
+ * Adapt a raw database client to the executor the planner needs.
+ *
+ * Each client reports rows differently, so the shape is detected rather than
+ * configured: `pg` returns `{ rows }`, `mysql2` returns `[rows]`, and
+ * `node:sqlite` exposes prepare/exec. A key-value storage mount has no tables,
+ * which is reported as `null` rather than an error.
+ */
+declare function createSchemaExecutor(client: unknown, owner: string): {
+    executor: FarmSchemaExecutor;
+    dialect: FarmSqlDialect;
+} | null;
+
+/**
+ * What Farm last applied for each owner, kept in the app's database: the
+ * owner's version and a snapshot of its tables. Comparing it with what the
+ * installed version declares tells the app what an upgrade changes.
+ */
+declare const FARM_SCHEMA_STATE_TABLE = "farm_schema_state";
+/** An owner's tables, in database terms, independent of dialect. */
+type FarmSchemaSnapshot = {
+    tables: Record<string, {
+        columns: Record<string, {
+            type: string;
+            nullable: boolean;
+            primaryKey: boolean;
+            unique: boolean;
+            default?: unknown;
+        }>;
+        indexes: string[];
+    }>;
+};
+type FarmSchemaState = {
+    version?: string;
+    snapshot: FarmSchemaSnapshot;
+    appliedAt: string;
+};
+type FarmSchemaChanges = {
+    addedTables: string[];
+    addedColumns: Array<{
+        table: string;
+        column: string;
+        type: string;
+    }>;
+    addedIndexes: string[];
+    /** Removed or redefined: never applied on their own. */
+    otherChanges: string[];
+    /** Columns the new version no longer has, with their old type. */
+    removedColumns?: Array<{
+        table: string;
+        column: string;
+        type: string;
+    }>;
+};
+
+/** Where Farm records the steps it ran for each owner. */
+declare const FARM_SCHEMA_STEPS_TABLE = "farm_schema_steps";
+type FarmPlannedSchemaStep = {
+    step: FarmSchemaMigrationStep;
+    /** What the step does, in the app's names. */
+    summary: string;
+    phase: "before" | "after";
+    statements: string[];
+    /**
+     * `run`: pending. `record`: the database already has the step's effect, so
+     * it is only recorded. `blocked`: it cannot run; `reason` says why.
+     */
+    state: "run" | "record" | "blocked";
+    reason?: string;
+    /** Deletes data: runs only with `--allow-destructive`. */
+    destructive?: boolean;
+};
+type FarmSchemaStepPlan = {
+    steps: FarmPlannedSchemaStep[];
+    /** Steps that ran here before, but whose definition has changed since. */
+    edited: string[];
+    /** Every step, when the tables are being created fresh at this version. */
+    fresh: boolean;
+};
+
+/**
+ * Attached to a plugin or integration to say "I own these tables".
+ *
+ * Read by tooling so it can reach an already-resolved schema and connection
+ * instead of re-reading and re-validating configuration.
+ *
+ * @internal
+ */
+declare const FARM_SCHEMA_TABLES: unique symbol;
+/** @internal What `definePlugin({ schema })` records on a plugin. */
+interface FarmSchemaTablesDeclaration {
+    /** Command namespace: this is the `<name>` in `farm <name> migrate`. */
+    name: string;
+    /** The schema whose models this owner stores. */
+    schema: FarmSchema;
+    /**
+     * Model keys this owner actually controls. Defaults to every model in the
+     * schema; narrow it when an app shares one schema with the rest of its code.
+     */
+    models?: readonly string[];
+    /**
+     * Resolves the configured database client, or the storage mount behind it.
+     *
+     * The app's resolved config is passed because an owner may read its
+     * connection from there rather than from its own options — an integration
+     * configured through `storage.client`, for example.
+     */
+    resolveClient(config: FarmSchemaOwnerConfig): Promise<unknown>;
+    /** Set explicitly when the client's dialect cannot be detected. */
+    dialect?: FarmSqlDialect;
+    /** Owners whose tables must exist first, by owner name. */
+    dependsOn?: readonly string[];
+    /** The owner's release, shown when an upgrade changes its tables. */
+    version?: string;
+    /** Ordered steps for changes Farm does not infer, such as renames. */
+    migrations?: readonly FarmSchemaMigrationStep[];
+}
+/**
+ * Record that a plugin or integration owns tables, so `farm <name> migrate`,
+ * `farm generate`, and `farm schema check` find them.
+ *
+ * @internal Not part of the plugin API: plugins set `schema` (and `database`)
+ * on `definePlugin`, which calls this. Exported for Farm's own packages and for
+ * code written against earlier betas.
+ *
+ * The declaration is non-enumerable, so it never reaches a config serializer or
+ * a plugin's own option spreading.
+ */
+declare function declareSchemaTables<TTarget extends object>(target: TTarget, declaration: FarmSchemaTablesDeclaration): TTarget;
+/** @internal The declaration on a plugin, when it has one. */
+declare function readSchemaTables(candidate: unknown): FarmSchemaTablesDeclaration | undefined;
+/** What an owner may read when resolving its client. */
+type FarmSchemaOwnerConfig = {
+    storage?: unknown;
+    integrations?: Record<string, unknown> | readonly unknown[];
+    [key: string]: unknown;
+};
+
+/** A reference from one plugin's table to a table another plugin creates. */
+type FarmCrossOwnerReference = {
+    /** The owner whose table holds the reference. */
+    owner: string;
+    modelKey: string;
+    fieldKey: string;
+    table: string;
+    column: string;
+    referencedOwner: string;
+    referencedTable: string;
+    referencedColumn: string;
+    onDelete: NonNullable<FarmSchemaReference["onDelete"]>;
+};
+
+/**
+ * Every table owner an app has configured.
+ *
+ * Plugins and integrations are both searched, because either can own storage.
+ */
+declare function findSchemaTableOwners(config: {
+    plugins?: readonly unknown[];
+    integrations?: Record<string, unknown> | readonly unknown[];
+}): FarmSchemaTablesDeclaration[];
+/** Resolve one owner's declaration into the models tooling works with. */
+declare function collectOwnerModels(owner: FarmSchemaTablesDeclaration): CollectedSchemaModel[];
+interface MigrateSchemaTablesOptions {
+    /** The app's resolved config, handed to the owner's `resolveClient`. */
+    config?: FarmSchemaOwnerConfig;
+    /** Write the plan to this path instead of applying it. */
+    write?: string;
+    /** Execute the plan. */
+    apply?: boolean;
+    /**
+     * What to do with columns the owner adds to tables it does not own.
+     * `"report"` when the app's ORM owns those tables: they are never altered,
+     * only reported, so the ORM's migrations stay the source of truth.
+     */
+    extensions?: "apply" | "report";
+    /** Run migration steps that delete data, such as dropping a column. */
+    allowDestructive?: boolean;
+    log?: (message: string) => void;
+}
+interface MigrateSchemaTablesResult {
+    plan: FarmSchemaMigratePlan;
+    sql: string;
+    applied: string[];
+    /** Foreign keys to other owners' tables that this run did not create. */
+    foreignKeys: {
+        /** The other owner has not created its table yet. */
+        waiting: FarmCrossOwnerReference[];
+        /** On an existing table, not allowed in `schema.allowForeignKeys`. */
+        unapproved: FarmSchemaAddableForeignKey[];
+        /** On an existing SQLite table, which cannot get one. */
+        unsupported: FarmSchemaAddableForeignKey[];
+        /** Allowed, but rows already point at nothing. */
+        blocked: Array<{
+            key: FarmSchemaAddableForeignKey;
+            orphans: number;
+        }>;
+    };
+    /** What the installed version changes compared with the last applied one. */
+    upgrade?: {
+        from?: string;
+        to?: string;
+        changes: FarmSchemaChanges;
+    };
+    /** The owner's migration steps: what ran now, and what is still to do. */
+    steps: {
+        plan?: FarmSchemaStepPlan;
+        ran: string[];
+        pending: string[];
+    };
+    /** Statements and steps `--apply` would run. */
+    planned: number;
+    /** Columns the owner adds to tables it does not own. */
+    extensions: FarmSchemaExtensionPlan & {
+        /** Additions the app has not allowed in `schema.allowExtend`. */
+        unapproved: FarmSchemaExtensionStatement[];
+        /** `table.column` still missing after this run, whatever the reason. */
+        pending: string[];
+    };
+}
+/**
+ * Plan, and optionally apply, the tables one owner needs.
+ *
+ * Nothing is executed unless `apply` is set: the default is to hand back sql a
+ * person can read before it touches a database. Columns added to tables the
+ * owner does not own also need the app's `schema.allowExtend`.
+ */
+declare function migrateSchemaTables(owner: FarmSchemaTablesDeclaration, options?: MigrateSchemaTablesOptions): Promise<MigrateSchemaTablesResult>;
+
+type DependencyOwner = {
+    name: string;
+    schema: FarmSchema;
+    models?: readonly string[];
+    dependsOn?: readonly string[];
+};
+/**
+ * Which owners need which, by owner name: what they declare in `dependsOn`,
+ * plus what their schemas imply. A reference to, or columns added to, a
+ * table another owner creates makes that owner a dependency. An owner whose
+ * schema cannot be resolved contributes only what it declares.
+ */
+declare function collectSchemaDependencies(owners: readonly DependencyOwner[]): Map<string, Set<string>>;
+/**
+ * Owners with their dependencies first, otherwise in the order given. When
+ * owners only refer to each other, every one is still listed exactly once:
+ * without foreign keys between them, either can be created first.
+ */
+declare function orderSchemaOwners<TOwner extends DependencyOwner>(owners: readonly TOwner[], dependencies?: ReadonlyMap<string, ReadonlySet<string>>): TOwner[];
+
+interface FarmProviderProps {
+    children: ReactNode;
+    config: FarmConfig;
+}
+/**
+ * Farm.js context provider for client-side components
+ */
+declare function FarmProvider({ children, config }: FarmProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Real table and column names for a schema's models, keyed by the names the
+ * schema uses. An app passes these to a plugin to point it at its own tables:
+ *
+ * ```ts
+ * teams({
+ *   schema: {
+ *     user: { name: "members_auth", fields: { id: "user_id" } },
+ *     member: { name: "team_members" },
+ *   },
+ * });
+ * ```
+ */
+type FarmSchemaRenames<TSchema extends FarmSchema = FarmSchema> = {
+    [TModel in keyof TSchema["models"] & string]?: {
+        /** The table's real name. */
+        name?: string;
+        /** Real column names, keyed by the schema's field names. */
+        fields?: {
+            [TField in keyof TSchema["models"][TModel]["fields"] & string]?: string;
+        };
+    };
+};
+/**
+ * Apply an app's renames to a schema. Only names change: the plugin keeps
+ * using its own model and field names in code, and every consumer of the
+ * schema (migrate, `farm generate`, `farm schema check`, and the runtime ORM)
+ * reads the real ones.
+ *
+ * A rename for a model or field the schema does not have is an error, so a
+ * typo fails while the config loads instead of pointing at a missing table.
+ */
+declare function renameSchema<TSchema extends FarmSchema>(schema: TSchema, renames: FarmSchemaRenames<TSchema> | undefined): TSchema;
+
+/**
+ * Read-only checks of every schema owner against the real database.
+ *
+ * Owners are integrations that declare a `schema` and plugins that declare
+ * tables. Their tables are compared with what the database holds, and every
+ * reference to a table someone else owns (the app's ORM, an auth library,
+ * another plugin) is checked too: the table must exist and the referenced
+ * column must have a type a foreign key can use. Nothing is written.
+ */
+type FarmSchemaCheckSeverity = "error" | "warning";
+type FarmSchemaCheckCode = "schema-invalid" | "owner-conflict" | "table-conflict" | "client-missing" | "client-unavailable" | "client-unsupported" | "table-missing" | "column-missing" | "column-type" | "column-definition" | "index-missing" | "foreign-key-missing" | "reference-table-missing" | "reference-column-missing" | "reference-type" | "extend-invalid" | "extend-table-missing" | "extend-column-missing" | "extend-column-type" | "extend-column-shared" | "schema-upgrade" | "migration-step-pending" | "migration-step-blocked" | "migration-step-edited";
+interface FarmSchemaCheckIssue {
+    severity: FarmSchemaCheckSeverity;
+    code: FarmSchemaCheckCode;
+    /** The integration key or plugin name that declares the schema. */
+    owner: string;
+    table?: string;
+    column?: string;
+    message: string;
+    /** What to do about it. */
+    hint?: string;
+}
+interface FarmSchemaCheckOwner {
+    name: string;
+    kind: "integration" | "plugin";
+    dialect?: FarmSqlDialect;
+    /** False when the owner stores data in a key/value mount, which has no tables. */
+    relational: boolean;
+    tables: string[];
+    /** Owners whose tables this one needs, declared or implied by its schema. */
+    dependsOn: string[];
+}
+interface FarmSchemaCheckReport {
+    owners: FarmSchemaCheckOwner[];
+    issues: FarmSchemaCheckIssue[];
+    /** True when there are no errors. Warnings do not fail a check. */
+    ok: boolean;
+}
+type FarmSchemaCheckConfig = FarmSchemaOwnerConfig & {
+    plugins?: readonly unknown[];
+};
+interface FarmSchemaCheckOptions {
+    /**
+     * How long connecting, and each query, may take before the owner is
+     * reported unreachable. A pg client has no connect timeout of its own, so
+     * an unreachable host would otherwise hang the check. Default 10 seconds.
+     */
+    timeoutMs?: number;
+}
+type SchemaOwner = {
+    name: string;
+    kind: "integration" | "plugin";
+    schema: FarmSchema;
+    models?: readonly string[];
+    dialect?: FarmSqlDialect;
+    dependsOn?: readonly string[];
+    version?: string;
+    migrations?: readonly FarmSchemaMigrationStep[];
+    resolveClient(config: FarmSchemaCheckConfig): Promise<unknown>;
+};
+/**
+ * Every owner of database tables in an app: integrations that declare a
+ * `schema` and plugins that declare tables. An integration that also
+ * contributes a table-owning plugin under the same name is listed once.
+ */
+declare function collectSchemaOwners(config: FarmSchemaCheckConfig): SchemaOwner[];
+declare function checkSchema(config: FarmSchemaCheckConfig, options?: FarmSchemaCheckOptions): Promise<FarmSchemaCheckReport>;
+/** Human-readable report, grouped by owner. */
+declare function formatSchemaCheck(report: FarmSchemaCheckReport): string;
+
+declare class HMRManager {
+    private server;
+    constructor(server: ViteDevServer);
+    /**
+     * Send HMR update to client
+     */
+    send(payload: any): Promise<void>;
+    /**
+     * Trigger full page reload
+     */
+    reloadPage(): Promise<void>;
+    /**
+     * Handle file change and trigger HMR
+     */
+    handleFileChange(file: string): Promise<void>;
+    /**
+     * Get all affected modules in the dependency graph
+     */
+    private getAffectedModules;
+    /**
+     * Handle custom HMR events from client
+     */
+    onClientMessage(event: string, callback: (data: any) => void): void;
+}
+
+interface APIRouteInfo {
+    path: string;
+    methods: string[];
+    filePath: string;
+    relativePath: string;
+}
+declare class APITypeGenerator {
+    private appDirs;
+    constructor(appDir: string | readonly string[]);
+    /**
+     * Scan all API route files and extract route information
+     */
+    scanAPIRoutes(): APIRouteInfo[];
+    private scanDirectory;
+    private extractRouteInfo;
+    private extractExportedMethods;
+    private isTypeOnlyExportSpecifier;
+    /**
+     * Generate TypeScript code for the API router
+     */
+    generateAPIRouter(routes: APIRouteInfo[], options?: {
+        outFile?: string;
+        pluginConfigs?: readonly string[];
+        pluginRoutes?: readonly {
+            path: string;
+            method: string;
+        }[];
+    }): string;
+    private getRouteImportPath;
+    private pathToRouteName;
+    private uniqueRouteName;
+    private structureToTypeString;
+    private toTypePropertyKey;
+    /**
+     * Generate the API index file
+     */
+    generateAPIIndex(outputPath: string): void;
+}
+
+interface OpenAPISpec {
+    openapi: string;
+    info: {
+        title: string;
+        description?: string;
+        version: string;
+        contact?: {
+            name?: string;
+            email?: string;
+            url?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+        };
+    };
+    servers?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    paths: Record<string, any>;
+    components?: {
+        schemas?: Record<string, any>;
+        securitySchemes?: Record<string, any>;
+    };
+}
+interface OpenAPIGeneratorContext {
+    mode?: "development" | "production";
+    /** Resolved Farm `api.baseURL`, including its API path. */
+    apiBaseURL?: string;
+}
+declare class OpenAPIGenerator {
+    private config;
+    private appDir;
+    private context;
+    constructor(appDir: string, config: OpenAPIConfig, context?: OpenAPIGeneratorContext);
+    /**
+     * Get type from Zod type
+     */
+    private getTypeFromZodType;
+    /**
+     * Whether a schema field must be supplied by the caller. A field with a
+     * default is supplied by the server when omitted, so — like an explicitly
+     * optional field — it is not required. Only ZodOptional was excluded before,
+     * which documented every `.default()` field as required.
+     */
+    private isRequiredField;
+    /**
+     * Process Zod type to OpenAPI schema
+     */
+    private processZodType;
+    private getResponses;
+    private getResponse;
+    /**
+     * Generate OpenAPI spec from API routes
+     */
+    generateSpec(routes: APIRouteInfo[], requestOrigin?: string): Promise<OpenAPISpec>;
+    /**
+     * Resolve server entries in decreasing order of authority: explicit OpenAPI
+     * servers, Farm's public API base, the current development request origin,
+     * and finally a mode-appropriate default.
+     */
+    resolveServers(requestOrigin?: string): NonNullable<OpenAPISpec["servers"]>;
+    /**
+     * Convert a Farm.js API path to OpenAPI path format.
+     *
+     * Strips the `/api` prefix and rewrites dynamic segments to OpenAPI's
+     * `{name}` templating: `[id]` -> `{id}`, `[...slug]` -> `{slug}`, and
+     * `[[...slug]]` -> `{slug}`. Leaving the bracket form produces a path key that
+     * is invalid OpenAPI, which breaks "try it" and any generated client.
+     */
+    private convertToOpenAPIPath;
+    /**
+     * OpenAPI does not permit optional path parameters. An optional catch-all
+     * therefore becomes two concrete paths: the empty base path and the
+     * parameterized catch-all path.
+     */
+    private getOpenAPIPathVariants;
+    /**
+     * Path parameters implied by a Farm.js API path's dynamic segments. Every
+     * path parameter is `required: true` per the OpenAPI spec (a path parameter
+     * cannot be optional), including catch-all segments.
+     */
+    private getPathParameters;
+    /**
+     * Extract request body schema from endpoint
+     */
+    private getRequestBody;
+    /**
+     * Extract query parameters from endpoint
+     */
+    private getParameters;
+    /**
+     * Generate OpenAPI operation from route info
+     */
+    private generateOperation;
+    private getEndpointOpenAPIMetadata;
+    private getSecurityRequirements;
+    /**
+     * Generate operation summary
+     */
+    private generateSummary;
+    /**
+     * Generate operation description
+     */
+    private generateDescription;
+    /**
+     * Generate operation ID
+     */
+    private generateOperationId;
+    /**
+     * Generate tags for grouping operations
+     */
+    private generateTags;
+    /**
+     * Generate OpenAPI spec file
+     */
+    generateSpecFile(routes: APIRouteInfo[], outputPath: string): Promise<void>;
+}
+
+declare class OpenAPIManager {
+    private generator;
+    private apiTypeGenerator;
+    private config;
+    private appDir;
+    private specCache;
+    constructor(appDir: string | readonly string[], config: OpenAPIConfig, context?: OpenAPIGeneratorContext);
+    /**
+     * Generate OpenAPI spec from API routes
+     */
+    generateSpec(): Promise<any>;
+    /**
+     * Get cached spec or generate new one
+     */
+    getSpec(requestOrigin?: string): Promise<any>;
+    /**
+     * Generate and save OpenAPI spec file
+     */
+    generateSpecFile(): Promise<void>;
+    /**
+     * Invalidate cache and regenerate spec
+     */
+    invalidateCache(): Promise<void>;
+    /**
+     * Get the docs route handler
+     */
+    getDocsRouteHandler(requestOrigin?: string): (req: any, res: any) => Promise<void>;
+}
+
+interface ScalarAPIDocumentationProps {
+    spec: any;
+    config?: {
+        theme?: "default" | "purple" | "blue" | "green" | "red" | "yellow";
+        layout?: "modern" | "classic";
+        showSidebar?: boolean;
+        hideDownloadButton?: boolean;
+        hideTryItPanel?: boolean;
+    };
+}
+declare function ScalarAPIDocumentation({ spec, config }: ScalarAPIDocumentationProps): react_jsx_runtime.JSX.Element;
+declare global {
+    interface Window {
+        Scalar?: {
+            createApiReference(element: Element, config: Record<string, unknown>): {
+                destroy(): void;
+            };
+        };
+    }
+}
+
+interface DocsRouteProps {
+    spec: any;
+    config?: any;
+}
+declare function DocsRoute({ spec, config }: DocsRouteProps): react_jsx_runtime.JSX.Element;
+
+type FarmDevtoolsRuntime = {
+    runtime: "auto" | "node" | "edge";
+    regions?: string[];
+    maxDuration?: number;
+};
+type FarmDevtoolsDiagnostic = {
+    severity: "error" | "warning" | "info";
+    code: string;
+    title: string;
+    message: string;
+    action?: string;
+};
+type FarmDevtoolsSnapshot = {
+    generatedAt: string;
+    health: "ready" | "attention" | "error";
+    project: {
+        name: string;
+        root: string;
+        srcDir: string;
+        basePath: string;
+        deploymentId: string;
+    };
+    deployment: {
+        target: string;
+        preset: string;
+        outputDir?: string;
+    };
+    counts: {
+        pages: number;
+        layouts: number;
+        loadingBoundaries: number;
+        errorBoundaries: number;
+        apiRoutes: number;
+        middleware: number;
+        integrations: number;
+        plugins: number;
+        storageMounts: number;
+        cronJobs: number;
+        workflows: number;
+        layers: number;
+        diagnostics: number;
+    };
+    routes: Array<{
+        kind: "page" | "layout" | "loading" | "error";
+        pattern: string;
+        filePath: string;
+        runtime?: FarmDevtoolsRuntime;
+    }>;
+    apiRoutes: Array<{
+        path: string;
+        methods: string[];
+        filePath: string;
+        runtime: FarmDevtoolsRuntime;
+    }>;
+    middleware: Array<{
+        path: string;
+        source: "config" | "file";
+        filePath: string;
+        handlerCount: number;
+    }>;
+    integrations: Array<{
+        key: string;
+        type: string;
+        category: string;
+        serverRuntime: boolean;
+        routes: Array<{
+            path: string;
+            methods: string[];
+        }>;
+        middlewareCount: number;
+        providerCount: number;
+        schemaModelCount: number;
+    }>;
+    plugins: Array<{
+        name: string;
+        version?: string;
+        order: number;
+        enforce: "pre" | "normal" | "post";
+        serverHooks: string[];
+        clientHooks: string[];
+        routes: boolean;
+    }>;
+    storage: Array<{
+        mount: string;
+        driver: string;
+        default: boolean;
+    }>;
+    cron: FarmCronJob[];
+    workflows: Array<{
+        id: string;
+        filePath: string;
+        routePath: string;
+        schedule: string[];
+        timezone?: string;
+    }>;
+    layers: Array<{
+        name: string;
+        source: string;
+        srcDir: string;
+    }>;
+    environment: {
+        server: string[];
+        public: string[];
+    };
+    docs: {
+        enabled: boolean;
+        entry?: string;
+    };
+    features: {
+        openapi: boolean;
+        markdown: boolean;
+        serverComponents: boolean;
+        serverActions: boolean;
+        optimizedBoundary: boolean;
+        observability: boolean;
+    };
+    diagnostics: FarmDevtoolsDiagnostic[];
+};
+
+interface GenerateFarmI18nTypesOptions {
+    root: string;
+    srcDir?: string;
+    config: ResolvedFarmI18nConfig;
+    outFile?: string;
+}
+declare function generateFarmI18nTypes(options: GenerateFarmI18nTypesOptions): Promise<string | undefined>;
+
+interface GenerateFarmTypeArtifactsOptions {
+    root: string;
+    srcDir?: string;
+    configPath?: string;
+    plugins?: readonly FarmPlugin[];
+    extraRoutes?: string[];
+    layers?: readonly ResolvedFarmLayer[];
+    suppressLintOnLink?: boolean;
+    componentExtensions?: readonly string[];
+    routeTypesOutFile?: string;
+    apiTypesOutFile?: string;
+    envTypesOutFile?: string;
+    imageTypesOutFile?: string;
+    i18nTypesOutFile?: string;
+    i18nConfig?: ResolvedFarmI18nConfig;
+    routes?: boolean;
+    api?: boolean;
+    env?: boolean;
+    images?: boolean;
+    i18n?: boolean;
+    /** Compare generated content with disk without writing files. */
+    check?: boolean;
+}
+interface GenerateFarmTypeArtifactsResult {
+    typesPath?: string;
+    routeTypesPath?: string;
+    apiTypesPath?: string;
+    envTypesPath?: string;
+    imageTypesPath?: string;
+    i18nTypesPath?: string;
+    apiRoutes: APIRouteInfo[];
+    /** Generated files whose checked-in content is missing or stale. */
+    stalePaths: string[];
+}
+declare function generateFarmTypeArtifacts(options: GenerateFarmTypeArtifactsOptions): Promise<GenerateFarmTypeArtifactsResult>;
+
+interface GenerateFarmImageTypesOptions {
+    root: string;
+    srcDir?: string;
+    outFile?: string;
+}
+declare function generateFarmImageTypes(options: GenerateFarmImageTypesOptions): string;
+declare function createFarmImageTypeDeclarations(): string;
+
+export { APITypeGenerator, CollectedSchemaModel, DocsRoute, FARM_SCHEMA_STATE_TABLE, FARM_SCHEMA_STEPS_TABLE, FARM_SCHEMA_TABLES, FarmConfig, FarmCronJob, type FarmCrossOwnerReference, type FarmDevtoolsDiagnostic, type FarmDevtoolsRuntime, type FarmDevtoolsSnapshot, FarmPlugin, FarmProvider, FarmSchema, type FarmSchemaAddableForeignKey, type FarmSchemaChanges, type FarmSchemaCheckCode, type FarmSchemaCheckConfig, type FarmSchemaCheckIssue, type FarmSchemaCheckOptions, type FarmSchemaCheckOwner, type FarmSchemaCheckReport, type FarmSchemaCheckSeverity, type FarmSchemaColumnDefinition, type FarmSchemaColumnDrift, type FarmSchemaDrift, type FarmSchemaExecutor, type FarmSchemaExtension, type FarmSchemaExtensionPlan, type FarmSchemaExtensionStatement, FarmSchemaField, type FarmSchemaIndexDefinition, type FarmSchemaMigratePlan, type FarmSchemaMigrateResult, FarmSchemaMigrationStep, type FarmSchemaOwnerConfig, FarmSchemaReference, type FarmSchemaReferenceDefinition, type FarmSchemaRenames, type FarmSchemaSnapshot, type FarmSchemaState, type FarmSchemaStepPlan, type FarmSchemaTableDescription, type FarmSchemaTablesDeclaration, FarmSqlDialect, FarmSqlStatement, type GenerateFarmImageTypesOptions, type GenerateFarmTypeArtifactsOptions, type GenerateFarmTypeArtifactsResult, HMRManager, type MigrateSchemaTablesOptions, type MigrateSchemaTablesResult, OpenAPIConfig, OpenAPIGenerator, OpenAPIManager, type OpenAPISpec, ResolvedFarmI18nConfig, ResolvedFarmLayer, ResolvedSchemaField, ScalarAPIDocumentation, applySchemaMigration, assertNoSchemaListField, checkSchema, collectOwnerModels, collectSchemaDependencies, collectSchemaExtensions, collectSchemaOwners, columnTypeFamily, createFarmImageTypeDeclarations, createSchemaExecutor, declareSchemaTables, describeSchemaDrift, describeSchemaTable, findSchemaTableOwners, formatSchemaCheck, formatSchemaMigration, generateFarmI18nTypes, generateFarmImageTypes, generateFarmTypeArtifacts, isSchemaExtensionAllowed, migrateSchemaTables, orderSchemaOwners, planSchemaExtensions, planSchemaMigration, readSchemaTables, renameSchema };