@farm.js/core 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/index.d.ts

@@ -0,0 +1,480 @@
+import { F as FarmConfig, ad as OpenAPIConfig, K as ResolvedFarmLayer, O as FarmSourceRoot, s as RouteModule, I as SSGCollectionResult, H as SSGPage } from './client-plugins-DuuleQKk.js';
+export { bb as APIHandlerLifecyclePayload, b7 as APIRouteDiscoveredPayload, A as AppRoutePattern, D as BuildOptions, be as BundleLifecyclePayload, _ as BundleResultPayload, cV as CookieJar, cW as CookieOptions, cK as CreateIntegrationOrmOptions, dr as DEFAULT_FARM_DEVTOOLS_SHORTCUT, cq as DefinedIntegration, r as ErrorBoundary, bc as ErrorLifecyclePayload, E as ErrorProps, dt as FARM_DEVTOOLS_LAUNCH_PARAM, ds as FARM_DEVTOOLS_PATH, bG as FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY, h as FarmAppContext, aA as FarmAuthConfig, aB as FarmAuthDatabaseConfig, aC as FarmAuthEmailAndPasswordConfig, aD as FarmAuthSessionConfig, aE as FarmAuthUserConfig, g as FarmContextFactory, e as FarmContextFactoryInput, au as FarmCspConfig, aw as FarmCspDirectiveValue, av as FarmCspDirectives, ax as FarmCspOptions, bo as FarmDeployConfig, bq as FarmDeployTarget, du as FarmDevtoolsConfig, dv as FarmDevtoolsUserConfig, a0 as FarmIntegration, br as FarmIntegrationCategory, bK as FarmIntegrationConfigContext, bL as FarmIntegrationConfigDefinition, bM as FarmIntegrationConfigInput, cd as FarmIntegrationContributedPlugin, bR as FarmIntegrationData, b$ as FarmIntegrationDocumentNavigation, ck as FarmIntegrationEndpointValue, cl as FarmIntegrationEndpoints, cn as FarmIntegrationEndpointsFactory, cm as FarmIntegrationEndpointsFactoryContext, bS as FarmIntegrationHandlerContext, bD as FarmIntegrationInputSchema, bP as FarmIntegrationLifecycleContext, bQ as FarmIntegrationLifecycleHook, bN as FarmIntegrationLifecycleLogLevel, bO as FarmIntegrationLifecycleLogger, ca as FarmIntegrationLogEvent, c9 as FarmIntegrationLogPhase, cb as FarmIntegrationLogger, bY as FarmIntegrationMiddleware, cF as FarmIntegrationOrmClient, cE as FarmIntegrationOrmSchema, cc as FarmIntegrationPluginOwner, b_ as FarmIntegrationProvider, bZ as FarmIntegrationProviderProps, bF as FarmIntegrationRequestContextStore, bV as FarmIntegrationRoute, bJ as FarmIntegrationRouteArgs, bH as FarmIntegrationRouteDb, ch as FarmIntegrationRouteFactory, bU as FarmIntegrationRouteHook, bT as FarmIntegrationRouteHookContext, by as FarmIntegrationRouteInput, bE as FarmIntegrationRouteInputSchemas, bw as FarmIntegrationRouteInputSource, bv as FarmIntegrationRouteMethod, bX as FarmIntegrationRouteMiddleware, bt as FarmIntegrationRouteParamValue, bu as FarmIntegrationRouteParams, bI as FarmIntegrationRouteStorageArgs, cj as FarmIntegrationRoutesFactory, ci as FarmIntegrationRoutesFactoryContext, c7 as FarmIntegrationSchema, c3 as FarmIntegrationSchemaConstraint, c2 as FarmIntegrationSchemaField, c0 as FarmIntegrationSchemaFieldType, c4 as FarmIntegrationSchemaModel, c5 as FarmIntegrationSchemaModelExtension, c6 as FarmIntegrationSchemaModelOverride, c1 as FarmIntegrationSchemaReference, bs as FarmIntegrationSlot, bC as FarmIntegrationStandardValidationResult, bA as FarmIntegrationValidationErrorLike, bz as FarmIntegrationValidationIssue, bx as FarmIntegrationValidationPathSegment, bB as FarmIntegrationValidationResult, ce as FarmIntegrationsUserConfig, ap as FarmLayerConfig, J as FarmLayerEntry, df as FarmMarkdownPageModuleInput, de as FarmMarkdownPageSource, db as FarmMdxComponent, dc as FarmMdxComponents, a4 as FarmMdxResolvedConfig, dd as FarmMdxUserConfig, a2 as FarmMiddlewareConfig, a as FarmMigrationCommand, b as FarmMigrationsConfig, c as FarmMigrationsUserConfig, aq as FarmPerformanceConfig, $ as FarmPlugin, b1 as FarmPluginBuildHooks, b3 as FarmPluginClientConfig, aG as FarmPluginContext, b2 as FarmPluginDevHooks, a_ as FarmPluginDiscoveredRoute, aH as FarmPluginIntegrationContext, aI as FarmPluginLifecycle, b0 as FarmPluginRenderHooks, aM as FarmPluginRouteRuntimePayload, a$ as FarmPluginRouterHooks, aS as FarmPluginRuntimeAfterEvent, aP as FarmPluginRuntimeBaseEvent, aR as FarmPluginRuntimeBeforeEvent, aV as FarmPluginRuntimeCloseEvent, aQ as FarmPluginRuntimeContextEvent, aT as FarmPluginRuntimeErrorEvent, aW as FarmPluginRuntimeHooks, aL as FarmPluginRuntimeKind, aY as FarmPluginRuntimeRequestHandler, aX as FarmPluginRuntimeRequestOptions, aZ as FarmPluginRuntimeSession, aU as FarmPluginRuntimeStartEvent, aN as FarmPluginSetupContext, aO as FarmPluginStateContext, ar as FarmPreloadMode, as as FarmPreloadUserConfig, x as FarmRequest, aJ as FarmRequestPluginContext, aK as FarmRequestStore, y as FarmResponse, d5 as FarmRouteRule, d4 as FarmRouteRuleCors, d3 as FarmRouteRuleRedirect, d2 as FarmRouteRuleRenderMode, d6 as FarmRouteRules, af as FarmRuntimeShutdownError, ay as FarmSecurityConfig, bW as FarmTypedIntegrationRoute, Z as FarmUserConfig, G as GenerateStaticParams, bd as HMRUpdatePayload, bj as HeaderConfig, bm as I18nConfig, bl as ImageConfig, cJ as InferFarmIntegrationOrmClient, cG as InferFarmIntegrationOrmField, cH as InferFarmIntegrationOrmFields, cI as InferFarmIntegrationOrmSchema, cO as IntegrationOrmModelNames, p as Layout, n as LayoutMetadataProps, v as LayoutModule, l as LayoutProps, q as Loading, L as LoadingProps, c$ as MemoryRateLimitStorageOptions, w as Metadata, m as MetadataProps, cU as MiddlewareChain, bn as MiddlewareConfig, cP as MiddlewareContext, b6 as MiddlewareDiscoveredPayload, cQ as MiddlewareFunction, M as MiddlewareProps, d1 as MiddlewareResult, cT as MiddlewareStore, d0 as NextFunction, bf as NitroBuildLifecyclePayload, N as NitroPreset, o as Page, j as PageProps, k as PagePropsWithMiddleware, P as PageRouteParams, C as ParsedRoute, i as PluginContextProps, ag as PluginManager, aF as PluginRequestContext, cX as RateLimitConfig, cY as RateLimitIncrementResult, c_ as RateLimitStatus, cZ as RateLimitStorage, a1 as ReadonlyMiddlewareStore, bi as RedirectConfig, ba as RenderLifecyclePayload, cR as RequestMiddleware, cS as RequestMiddlewareContext, a6 as ResolvedFarmAuthConfig, bh as ResolvedFarmConfig, az as ResolvedFarmCspConfig, bp as ResolvedFarmDeployConfig, a5 as ResolvedFarmDevtoolsConfig, R as ResolvedFarmMigrationsConfig, a7 as ResolvedFarmPerformanceConfig, at as ResolvedFarmPreloadConfig, a8 as ResolvedFarmSecurityConfig, bk as RewriteConfig, b4 as RouteDiscoveredPayload, b8 as RouteMatchPayload, b9 as RouteMatchResultPayload, B as RouteSegment, b5 as RoutesGeneratedPayload, z as ServerAction, bg as ShutdownPayload, t as StaticPathParams, S as StaticPathPrimitive, u as StaticRouteParams, dm as createFarmMarkdownRouteModule, dn as createFarmMarkdownRouteModuleFromFile, dq as createFarmMarkdownSourceResponse, cL as createIntegrationOrm, co as createIntegrationRoute, dl as createMarkdownMetadata, cr as defineIntegration, c8 as defineIntegrationSchema, ae as definePlugin, cD as dispatchIntegrationRequest, cN as farmIntegrationSchemaToOrmSchema, an as getDeployTargetForPreset, W as getFarmAppDirectories, cg as getFarmIntegrationPluginOwner, cf as getFarmIntegrationPluginServerRuntime, X as getFarmLayerAliases, V as getFarmSourceRoots, cv as getIntegrationDocumentNavigationMatchers, cu as getIntegrationProviders, cw as getIntegrationSchemas, ao as getPresetForDeployTarget, cC as getRegisteredIntegrationAPIManifest, cx as getRegisteredIntegrationRuntime, cz as getRegisteredIntegrationSchemas, cy as getRegisteredIntegrations, cp as integrationRoute, cs as isFarmIntegration, dh as isFarmMarkdownPageFile, ai as loadConfig, dp as loadFarmMdxComponents, cA as matchIntegrationRoute, cB as matchRegisteredIntegrationRoute, am as normalizeDeployTarget, di as normalizeFarmMarkdownRoutePath, d7 as normalizeRouteRules, dj as parseMarkdownFrontmatter, ah as resolveConfig, aj as resolveDeployConfig, al as resolveDeployOutputPath, dw as resolveFarmDevtoolsConfig, U as resolveFarmLayers, cM as resolveIntegrationOrmRuntimeClient, ct as resolveIntegrationPlugins, dg as resolveMdxConfig, ak as resolveMigrationsConfig, d9 as routeRulesToHeaders, da as routeRulesToNitroRouteRules, d8 as routeRulesToRedirects, dk as titleFromMarkdown } from './client-plugins-DuuleQKk.js';
+export { f as fileExists, g as globFiles, l as logger, m as matchRoute, p as parseRoutePath, a as parseSearchParams, r as resolveAppPath, s as segmentsToPattern, t as toViteModuleId } from './utils-3sQgfkya.js';
+export { 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';
+export { F as FarmIntegrationAPI, e as FarmIntegrationAPIBodyFormat, f as FarmIntegrationAPIMethod, a as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, h as FarmIntegrationRouteOperationCarrier, I as InferIntegrationAPIFromRoutes, b as api, d as defineIntegrationAPI, c as defineIntegrationAPIOperation, i as endpoint } from './integration-api-CHT2OKAf.js';
+export { c as createFarmApp } from './app-CTFnOJaI.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-D40lt6aN.js';
+export { F as FarmIslandStrategy } from './island-CfGru1MO.js';
+import { ViteDevServer } from 'vite';
+export { createCompressionPlugin, createEnvPlugin, createHeadersPlugin, createLoggerPlugin, createRedirectsPlugin, createRewritesPlugin } from './server-plugins.js';
+export { A as APIRouteMatch, c as APIRouteParamValue, b as APIRouteParams, s as AnyEndpointMiddleware, D as DELETE, f as EndpointErrorContracts, d as EndpointErrorDefinition, e as EndpointErrorDefinitions, g as EndpointErrorHandler, E as EndpointErrorSchema, h as EndpointFail, j as EndpointFailure, x as EndpointHandler, u as EndpointInvalidationContext, t as EndpointInvalidationTarget, v as EndpointInvalidations, r as EndpointMiddleware, p as EndpointMiddlewareContext, q as EndpointMiddlewareResult, w as EndpointOptions, l as EndpointParamValue, o as EndpointParams, G as GET, H as HEAD, I as InferEndpointMiddlewareContext, O as OPTIONS, B as PATCH, P as POST, z as PUT, T as TypedEndpoint, y as createEndpoint, i as invokeAPIRouteEndpoint, k as isEndpointFailure, a as isWebResponse, m as matchAPIRoute, n as normalizeRouteResponse } from './runtime-Bpp-c28k.js';
+export { APIRoute, APIRouteManager, APIRouteManagerOptions, API_ROUTE_METHODS } from './api/route-manager.js';
+export { r as APIClient, h as APIClientError, b as APIClientOptions, i as APIClientSystemError, c as APIClientWithoutIntegrationsOptions, g as APIResult, A as APIRouteRefMetadata, C as CacheKey, l as CacheOptions, k as CachePolicy, p as ClientOptions, a as FARM_API_ROUTE_META_SYMBOL, F as FARM_API_ROUTE_REF_SYMBOL, X as InferIntegrationOperationBody, Y as InferIntegrationOperationQuery, Z as InferIntegrationOperationResponse, T as IntegrationAPI, L as IntegrationClient, M as IntegrationClientAliases, V as IntegrationClientData, y as IntegrationClientError, P as IntegrationClientOptions, Q as IntegrationClientRequestOptions, N as IntegrationClientRoot, U as IntegrationClients, W as IntegrationOperationResult, _ as IntegrationServerClient, $ as IntegrationServerClientAliases, a0 as IntegrationServerClientOptions, a1 as IntegrationServerClientRequestOptions, a2 as IntegrationServerClientRoot, a3 as IntegrationServerRequestLike, n as InvalidateOptions, I as InvalidateTarget, o as OptimisticOptions, O as OptimisticUpdate, R as RequestEvent, j as ResponseEvent, m as RetryOptions, q as RouteAPIClient, s as ServerAPIClient, S as ServerAPIClientOptions, d as ServerAPIClientWithoutIntegrationsOptions, f as StatusEvent, e as StatusPhase, t as createAPIClient, z as createIntegrationApi, x as createIntegrationClient, B as createIntegrationClients, E as createIntegrationServerClient, D as createIntegrations, w as createServerAPIClient, v as getAPIRouteRefMetadata, G as getIntegrationAPIManifest, H as integrationClients, J as integrationsClient, K as integrationsServer, u as isAPIRouteRef } from './client-Nn0q4eO4.js';
+export { F as FarmAPIStream, c as FarmStreamResponse, a as MultipartField, M as MultipartSchema, b as MultipartValues, T as TypedFormData, e as isFarmAPIStream, d as isJSONStreamResponse, i as isMultipartSchema, j as jsonStream, m as multipart, r as readJSONStream, t as toFormData } from './transport-BmbGTXA5.js';
+export { ApiRoute, FarmApiPluginOptions, farmApiPlugin } from './api.js';
+export { 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-BALtrRim.js';
+export { FarmQueryStateContext, LayoutPropsSafe, PagePropsSafe, QueryStateConfig, QueryStateProvider } from './query/index.js';
+export { FarmMiddlewarePluginOptions, MiddlewareManager, UnsupportedRateLimitStorageError, createContext, farmMiddlewarePlugin, getFromMiddleware, getRateLimitStatus, hasMiddlewareData, memoryRateLimitStorage, middleware, unwrapMiddleware } from './middleware.js';
+export { _ as _runWithMiddlewareContext, b as _runWithMiddlewareData, a as applyProductionMiddlewareHeaders, c as createProductionMiddlewareRunner, g as getMiddlewareContext, d as getMiddlewareData, e as getMiddlewareValue } from './production-runtime-DrEy8kBO.js';
+export { FarmRouter, FarmRouterActiveOptions, FarmRouterBuildOptions, FarmRouterMatch, FarmRouterParams, FarmRouterPathParam, FarmRouterPathParams, FarmRouterPrimitiveParam, FarmRouterQueryValue, FarmRouterRoute, FarmRouterRouteInput, buildFarmRoutePath, createFarmRouter, isFarmRouteActive, matchFarmRoute } from './router.js';
+export { c as FarmRouteMaxDuration, b as FarmRouteRegions, e as FarmRouteRenderingMode, a as FarmRouteRuntime, F as FarmRouteRuntimeConfig, d as FarmRouteRuntimeEntryKind, g as FarmRouteRuntimeManifest, f as FarmRouteRuntimeManifestEntry, R as ResolvedFarmRouteRuntimeConfig, j as createFarmRouteRuntimeKey, l as farmRouteRuleMatches, i as getFarmRouteRuntimeConfig, h as hasFarmRouteRuntimeControls, m as mergeFarmRouteRuntimeConfigs, n as normalizeFarmRouteRuntimeConfig, k as resolveFarmRouteRuleRuntimeConfig, r as resolveFarmRouteRuntimeConfig } from './route-runtime-DoOHzCAD.js';
+export { CreateRouteOptions, InferProgrammaticRouteData, InferProgrammaticRouteSchema, ProgrammaticApiRoute, ProgrammaticApiRouteOptions, ProgrammaticLayoutRoute, ProgrammaticPageRoute, ProgrammaticRedirectRoute, ProgrammaticRouteBuilder, ProgrammaticRouteComponentProps, ProgrammaticRouteContext, ProgrammaticRouteDataCacheContext, ProgrammaticRouteDataCacheKeys, ProgrammaticRouteDataContext, ProgrammaticRouteDataHooks, ProgrammaticRouteDataStaleTime, ProgrammaticRouteDefinition, ProgrammaticRouteErrorComponentProps, ProgrammaticRouteFactory, ProgrammaticRouteGuard, ProgrammaticRouteGuardContext, ProgrammaticRouteManifest, ProgrammaticRouteMaybePromise, ProgrammaticRouteMethod, ProgrammaticRouteParamsFallback, ProgrammaticRoutePendingComponentProps, ProgrammaticRoutePrimitive, ProgrammaticRouteRenderMode, ProgrammaticRouteSchema, ProgrammaticRouteSearchClientOptions, ProgrammaticRouteSearchConfig, ProgrammaticRouteSearchFallback, ProgrammaticRouteSearchOptions, ProgrammaticStaticPath, ProgrammaticStaticPathParams, ProgrammaticStaticPaths, createLayoutModuleFromProgrammaticLayout, createProgrammaticRouteModuleId, createRoute, createRouteModuleFromProgrammaticPage, defineRoutes, getProgrammaticRouteManifest, isProgrammaticRouteManifest, isProgrammaticRoutesFileName, layout, page, parseProgrammaticRouteModuleId, parseProgrammaticRoutePath, routesBuilder, scanProgrammaticPagePaths } from './routes.js';
+export { FarmDocsAPIHandler, FarmDocsAPIOptions, FarmDocsAPIRouteHandlers, FarmDocsCloudIntegration, FarmDocsCloudRouteOptions, FarmDocsCloudServer, FarmDocsHandlerOptions, FarmDocsPage, LoadedFarmDocsPage, createDocsAPI, createFarmDocsAPIHandler, createFarmDocsHandler, discoverFarmDocsPages, getFarmDocsDocumentNavigationMatchers, getFarmDocsRouteTypeEntries, isFarmDocsAPIRequest, isFarmDocsRequest, loadFarmDocsPage, resolveFarmDocsContentDir } from './docs.js';
+export { b as FarmDocsConfigInput, c as FarmDocsNavigationConfig, F as FarmDocsResolvedConfig, f as FarmDocsSidebarItem, d as FarmDocsSocialImageConfig, e as FarmDocsSocialImageFonts, a as FarmDocsUserConfig } from './types-DTzm4TCl.js';
+export { ApplyMarkdownNegotiationHeadersOptions, CreateMarkdownMirrorResponseOptions, FarmMarkdownMirrorTarget, FarmMarkdownResolvedConfig, FarmMarkdownResolvedRoute, FarmMarkdownRouteInput, FarmMarkdownUserConfig, ResolveMarkdownMirrorTargetOptions, applyMarkdownNegotiationHeaders, createMarkdownMirrorResponse, htmlToMarkdown, requestAcceptsMarkdown, resolveMarkdownConfig, resolveMarkdownMirrorTarget } from './markdown.js';
+export { FarmAPIEvent, FarmBuildEvent, FarmCacheEvent, FarmErrorEvent, FarmEvent, FarmEventBase, FarmEventHandler, FarmEventInput, FarmEventLevel, FarmEventType, FarmIntegrationEvent, FarmMiddlewareEvent, FarmObservabilityUserConfig, FarmPPREvent, FarmPluginEvent, FarmRenderEvent, FarmResolvedObservabilityConfig, FarmRouteEvent, FarmServerEvent, FarmStorageEvent, configureFarmObservability, emitFarmEvent, normalizeFarmObservabilityConfig, onFarmEvent, resetFarmObservability } from './observability.js';
+export { D as DEFAULT_FARM_WORKFLOW_DIRS, o as DEFAULT_FARM_WORKFLOW_ROUTE, p as DEFAULT_FARM_WORKFLOW_SECRET_ENV, l as FarmCronDefinition, m as FarmDiscoveredWorkflow, a as FarmServerConfig, d as FarmServerDuration, e as FarmServerHealthConfig, k as FarmWorkflowDefinition, n as FarmWorkflowHTTPHandlerOptions, i as FarmWorkflowLogger, j as FarmWorkflowRunContext, h as FarmWorkflowSchedule, F as FarmWorkflowsResolvedConfig, g as FarmWorkflowsUserConfig, P as PreparedFarmWorkflows, R as ResolvedFarmServerConfig, f as ResolvedFarmServerHealthConfig, A as applyFarmWorkflowVercelCrons, w as createFarmWorkflowRequestHandler, z as createFarmWorkflowVercelCrons, t as defineCron, s as defineTask, q as defineWorkflow, v as discoverFarmWorkflows, y as prepareFarmWorkflowsForNitro, u as resolveWorkflowsConfig, x as runFarmWorkflowModule } from './workflows-CusFV6mn.js';
+export { DEFAULT_FARM_CRON_SECRET_ENV, FARM_CRON_MANIFEST, FarmCronCloudflareConfig, FarmCronJob, FarmCronJobConfig, FarmCronResolvedConfig, FarmCronRouteOptions, FarmCronSchedule, FarmCronUserConfig, PreparedFarmCron, applyFarmCronVercelCrons, createFarmCronCloudflareConfig, createFarmCronCloudflareTriggers, createFarmCronManifest, createFarmCronVercelCrons, cronRoute, isCronRequestAuthorized, mergeScheduledTasks, prepareFarmCronForNitro, resolveCronConfig } from './cron.js';
+export { EnvParser, EnvSchema, EnvShape, FarmEnvConfig, FarmEnvTypes, FarmPublicEnv, FarmServerEnv, FarmTypedEnv, InferEnv, InferEnvParser, InferEnvShape, ResolvedFarmEnv, 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 { c as FarmResolvedTheme, d as FarmThemeConfig, b as FarmThemePreference, a as FarmThemeSnapshot, R as ResolvedFarmThemeConfig } from './types-CsR8fpgF.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-BMxWr97v.js';
+export { g as FarmI18nCookieConfig, h as FarmI18nDetectionSignal, i as FarmI18nDirection, j as FarmI18nRouting, k as FarmI18nUserConfig } from './types-BMxWr97v.js';
+export { AnyServerFnMiddleware, FARM_SERVER_FN_SYMBOL, InferServerFnError, InferServerFnSchemaInput, InferServerFnSchemaOutput, ServerFn, ServerFnContext, ServerFnDeclaredError, ServerFnError, ServerFnErrorDefinition, ServerFnErrorDefinitions, ServerFnErrorHandler, ServerFnErrorSchema, ServerFnFormInput, ServerFnHandler, ServerFnHandlerContext, ServerFnInvalidationContext, ServerFnInvalidations, ServerFnMiddleware, ServerFnMiddlewareContext, ServerFnMiddlewareContinuation, ServerFnMiddlewareHandler, ServerFnMiddlewareHandlerContext, ServerFnMiddlewareNext, ServerFnMiddlewareOptions, ServerFnOptions, ServerFnOutputOptions, ServerFnSchema, _parseServerFnSchema, createServerFn, createServerMiddleware } from './server-fn.js';
+export { ServerFnActionStatus, ServerFnOptimisticContext, ServerFnSubmit, UseServerFnOptions, UseServerFnReturn, useServerFn } from './server-fn-client.js';
+export { FARM_SERVER_QUERY_SYMBOL, ServerQuery, ServerQueryKey, ServerQueryOptions, ServerQueryOutputOptions, ServerQueryStaleTime, createServerQuery } from './server-query.js';
+export { FarmServerQueryActionInvocation, ServerQueryFetchOptions, UseServerQueryOptions, UseServerQueryResult, beginFarmServerQueryAction, completeFarmServerQueryAction, fetchServerQuery, prefetchServerQuery, 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 FarmImageConfig, a as FarmImageFormat, b as FarmImageLocalPattern, c as FarmImageProvider, d as FarmImageRemotePattern, R as ResolvedFarmImageConfig } from './image-config-Duob7wER.js';
+export { build } from './internal/build-runtime.js';
+export { AnyMutationTarget, DefaultRouteHref, DefaultRoutePath, DefaultRoutePattern, ExternalHref, FarmNavigateOptions, FarmNavigationBlocker, FarmNavigationBlockerContext, FarmNavigationListener, FarmNavigationLocation, FarmNavigationState, FarmViewTransitionMode, FetcherFormDataContext, FetcherFormProps, FetcherState, FetcherSubmit, FetcherSubmitAsync, InferMutationData, InferMutationError, InferMutationVariables, Link, LinkDefaultRoute, LinkProps, MutationAsync, MutationOptimisticContext, MutationStatus, MutationTrigger, PrefetchBehavior, RouteHref, RouteOptionalParamValue, RouteParamValue, RouteParams, SPARouter, Store, StoreApi, StoreFields, StoreKeyListener, StoreKeysListener, StoreListener, StorePatch, StoreState, StoreValueUpdater, UseBlockerOptions, UseBlockerReturn, UseFetcherOptions, UseFetcherReturn, UseMutationOptions, UseMutationReturn, UseRouterOptions, createStore, getRouter, navigateTo, prefetch, pushState, readPageState, replaceState, useBlocker, useFetcher, useMutation, useNavigation, usePageState, useRouter, useScrollRestoration } from './client.js';
+export { UseThemeResult, getTheme, setTheme, toggleTheme, useTheme } from './theme/client.js';
+export { F as FarmChunkRecoveryOptions, i as installChunkErrorRecovery, a as isChunkLoadError } from './chunk-recovery-lnQFzcQP.js';
+export { a as FarmClientHydrationCompleteEvent, b as FarmClientHydrationEvent, d as FarmClientHydrationMode, e as FarmClientHydrationSession, f as FarmClientLocation, g as FarmClientNavigationAction, h as FarmClientNavigationErrorEvent, i as FarmClientNavigationEvent, j as FarmClientNavigationLoadedEvent, k as FarmClientNavigationResolvedEvent, l as FarmClientNavigationSession, m as FarmClientPerformanceEvent, n 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 './plugin-BJDf43dc.js';
+export { CacheKeyFactory, DefinedCacheKey, FarmCacheAdapter, FarmCacheEntry, FarmCacheInvalidationTarget, FarmCacheOptions, FarmCacheSetOptions, FarmCacheStorage, FarmCacheUserConfig, FarmDataCache, GetFarmCacheEntryOptions, InferCacheKeyData, RevalidateTagProfile, RouteDataCacheKey, StorageFarmCacheAdapterOptions, applyFarmCacheInvalidationTargets, applyFarmCacheInvalidations, configureFarmCache, 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, headers } from './headers.js';
+export { defineConfig, defineFarmConfig } from './config.js';
+export { F as FarmRedirectSignal, b as FarmRedirectStatus, g as getFarmRedirectError, i as isFarmNotFoundError, a as isFarmRedirectError, n as notFound, p as permanentRedirect, r as redirect } from './navigation-errors-Dvwpzaer.js';
+export { F as FarmStorageBuiltinDriverConfig, a as FarmStorageClient, b as FarmStorageClientConfig, c as FarmStorageConfigObject, d as FarmStorageCustomDriverConfig, e as FarmStorageDatabaseConfig, f as FarmStorageDatabaseDriverName, g as FarmStorageLocalDriverConfig, i as FarmStorageMountConfig, j as FarmStorageMounts, h as FarmStorageRuntimeClient, k as FarmStorageUserConfig } from './types-D1A6-XvH.js';
+export { BuiltinDriverName, BuiltinDriverOptions, Driver, Storage, StorageMeta, StorageValue, TransactionOptions } from 'unstorage';
+export { ConnectorName, ConnectorOptions, Database } from 'db0';
+export { F as FARM_SERVER_FN_FAILURE_SYMBOL, b as SerializedServerFnFailure, a as ServerActionError, S as ServerFnFailure, c as createServerFnTransportError, i as isServerFnFailure } from './server-fn-error-DDh14a0V.js';
+import 'http';
+import '@farming-labs/orm';
+import './metadata-DyPRG0wX.js';
+import './runtime-bv63eUiO.js';
+import './resolver-IH4RmPEl.js';
+import './client-cache-CIlyBlmx.js';
+import '@farming-labs/docs';
+import './internal/config-runtime.js';
+import 'node:http';
+
+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;
+
+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;
+    /**
+     * Generate TypeScript code for the API router
+     */
+    generateAPIRouter(routes: APIRouteInfo[], options?: {
+        outFile?: string;
+    }): string;
+    private getRouteImportPath;
+    private pathToRouteName;
+    private structureToTypeString;
+    private toTypePropertyKey;
+    private getBaseExportName;
+    private getExportName;
+    /**
+     * 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>;
+    };
+}
+declare class OpenAPIGenerator {
+    private config;
+    private appDir;
+    constructor(appDir: string, config: OpenAPIConfig);
+    /**
+     * Get type from Zod type
+     */
+    private getTypeFromZodType;
+    /**
+     * Process Zod type to OpenAPI schema
+     */
+    private processZodType;
+    /**
+     * Generate standard error responses
+     */
+    private getStandardResponses;
+    /**
+     * Generate OpenAPI spec from API routes
+     */
+    generateSpec(routes: APIRouteInfo[]): Promise<OpenAPISpec>;
+    /**
+     * Convert Farm.js API path to OpenAPI path format
+     */
+    private convertToOpenAPIPath;
+    /**
+     * Extract request body schema from endpoint
+     */
+    private getRequestBody;
+    /**
+     * Extract query parameters from endpoint
+     */
+    private getParameters;
+    /**
+     * Generate OpenAPI operation from route info
+     */
+    private generateOperation;
+    /**
+     * 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);
+    /**
+     * Generate OpenAPI spec from API routes
+     */
+    generateSpec(): Promise<any>;
+    /**
+     * Get cached spec or generate new one
+     */
+    getSpec(): 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(): (req: any, res: any) => Promise<void>;
+    /**
+     * Generate HTML for docs route
+     */
+    private generateDocsHTML;
+}
+
+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 {
+        ScalarApiReference: (config: any) => void;
+    }
+}
+
+interface DocsRouteProps {
+    spec: any;
+    config?: any;
+}
+declare function DocsRoute({ spec, config }: DocsRouteProps): react_jsx_runtime.JSX.Element;
+
+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;
+    extraRoutes?: string[];
+    layers?: readonly ResolvedFarmLayer[];
+    suppressLintOnLink?: boolean;
+    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;
+
+interface GenerateRouteTypesOptions {
+    root: string;
+    srcDir?: string;
+    outFile?: string;
+    extraRoutes?: string[];
+    /** Ordered layer roots followed by the project root. */
+    sourceRoots?: readonly FarmSourceRoot[];
+    /** When true, do not augment LinkDefaultRoute so Link href accepts any string (no route-type errors). */
+    suppressLintOnLink?: boolean;
+}
+/**
+ * Scan application route modules, generate page and module route unions,
+ * and write a .d.ts file for typed Link hrefs and route component props.
+ */
+declare function generateRouteTypes(options: GenerateRouteTypesOptions): Promise<string>;
+
+/**
+ * Farm.js SSG (Static Site Generation) Module
+ *
+ * Handles collection and pre-rendering of SSG pages at build time.
+ *
+ * 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
+ * ```tsx
+ * // SSG Page
+ * export const ssg = true;
+ * export default function AboutPage() {
+ *   return <h1>About</h1>;
+ * }
+ *
+ * // SSG with ISR
+ * export const ssg = true;
+ * export const revalidate = 60;
+ * export default async function ProductsPage() {
+ *   const products = await fetchProducts();
+ *   return <ProductList products={products} />;
+ * }
+ *
+ * // Dynamic SSG
+ * 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 }) {
+ *   return <article>{params.slug}</article>;
+ * }
+ *
+ * // Next-compatible route config
+ * export const dynamic = "force-static";
+ * export const revalidate = 60;
+ *
+ * // PPR/static-shell route
+ * export const experimental_ppr = true;
+ * export const revalidate = 60;
+ *
+ * // Directive config
+ * "use ssg; 60";
+ * export default function DocsPage() {
+ *   return <h1>Docs</h1>;
+ * }
+ * ```
+ */
+
+interface RouteEntry {
+    path: string;
+    filePath: string;
+    isDynamic: boolean;
+    pattern: string;
+}
+type RouteRenderingDynamic = NonNullable<RouteModule["dynamic"]>;
+interface RouteRenderingConfig {
+    ssg: boolean;
+    ppr: boolean;
+    revalidate?: number;
+    dynamic?: RouteRenderingDynamic;
+    directive?: string;
+}
+interface StaticRouteCandidateAnalysis {
+    candidate: boolean;
+    blockers: string[];
+}
+interface DirectiveRenderingConfig {
+    ssg: boolean;
+    ppr: boolean;
+    revalidate?: number;
+    dynamic?: RouteRenderingDynamic;
+    directive: string;
+}
+/**
+ * Resolve route rendering from Farm exports, Next-compatible exports, and
+ * top-of-file directives such as `"use ssg";` or `"use ssg; 60";`.
+ */
+declare function resolveRouteRenderingConfig(mod: RouteModule | null | undefined, source?: string): RouteRenderingConfig;
+declare function resolveRouteRenderingConfigFromFile(mod: RouteModule | null | undefined, filePath: string): Promise<RouteRenderingConfig>;
+/**
+ * Conservatively identify a route that may be safe to pre-render.
+ *
+ * This intentionally produces a suggestion rather than changing rendering:
+ * request-bound work can live in a transitive import, which source inspection
+ * of the route module cannot prove safe. Explicit route config always wins.
+ */
+declare function analyzeStaticRouteCandidate(mod: RouteModule | null | undefined, source: string | undefined, options?: {
+    isDynamic?: boolean;
+}): StaticRouteCandidateAnalysis;
+declare function parseRouteRenderingDirective(source: string | undefined): DirectiveRenderingConfig | undefined;
+/**
+ * Collect SSG pages from route modules
+ *
+ * Scans all routes and categorizes them into:
+ * - SSG pages: Pre-rendered at build time
+ * - SSR routes: Rendered on each request
+ *
+ * @param routes - Array of route entries
+ * @param loadModule - Function to load a route module
+ * @returns SSG pages and SSR routes
+ */
+declare function collectSSGPages(routes: RouteEntry[], loadModule: (filePath: string) => Promise<RouteModule>, options?: {
+    suggestStaticRendering?: boolean;
+}): Promise<SSGCollectionResult>;
+/**
+ * Check if a route module is SSG
+ */
+declare function isSSGModule(mod: RouteModule | null | undefined): boolean;
+/**
+ * Check if a route module has ISR (Incremental Static Regeneration)
+ */
+declare function hasISR(mod: RouteModule | null | undefined): boolean;
+/**
+ * Get revalidation interval for a module
+ */
+declare function getRevalidateInterval(mod: RouteModule | null | undefined): number | undefined;
+/**
+ * Check if a route module has PPR/static-shell caching enabled.
+ */
+declare function hasPPR(mod: RouteModule | null | undefined): boolean;
+/**
+ * Generate SSG manifest for production builds
+ */
+declare function generateSSGManifest(pages: SSGPage[]): string;
+/**
+ * Check if a URL path matches an SSG page
+ */
+declare function matchSSGPage(urlPath: string, ssgPages: SSGPage[]): SSGPage | undefined;
+
+export { APITypeGenerator, DocsRoute, FarmConfig, FarmProvider, type GenerateFarmImageTypesOptions, type GenerateFarmTypeArtifactsOptions, type GenerateFarmTypeArtifactsResult, type GenerateRouteTypesOptions, HMRManager, OpenAPIConfig, OpenAPIGenerator, OpenAPIManager, type OpenAPISpec, ResolvedFarmI18nConfig, ResolvedFarmLayer, RouteModule, type RouteRenderingConfig, type RouteRenderingDynamic, SSGCollectionResult, SSGPage, ScalarAPIDocumentation, type StaticRouteCandidateAnalysis, analyzeStaticRouteCandidate, collectSSGPages, createFarmImageTypeDeclarations, generateFarmI18nTypes, generateFarmImageTypes, generateFarmTypeArtifacts, generateRouteTypes, generateSSGManifest, getRevalidateInterval, hasISR, hasPPR, isSSGModule, matchSSGPage, parseRouteRenderingDirective, resolveRouteRenderingConfig, resolveRouteRenderingConfigFromFile };