@farm.js/core 0.1.0-beta.10 → 0.1.0-beta.11

package/dist/index.d.ts

@@ -0,0 +1,455 @@
+import { F as FarmConfig, a1 as OpenAPIConfig, C as ResolvedFarmLayer, D as FarmSourceRoot, p as RouteModule, z as SSGCollectionResult, y as SSGPage } from './client-plugins-Bc5jHcNr.js';
+export { aO as APIHandlerLifecyclePayload, aK as APIRouteDiscoveredPayload, B as BuildOptions, aR as BundleLifecyclePayload, U as BundleResultPayload, ct as CookieJar, cu as CookieOptions, ci as CreateIntegrationOrmOptions, cY as DEFAULT_FARM_DEVTOOLS_SHORTCUT, b_ as DefinedIntegration, o as ErrorBoundary, aP as ErrorLifecyclePayload, E as ErrorProps, c_ as FARM_DEVTOOLS_LAUNCH_PARAM, cZ as FARM_DEVTOOLS_PATH, bh as FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY, h as FarmAppContext, ad as FarmAuthConfig, ae as FarmAuthDatabaseConfig, af as FarmAuthEmailAndPasswordConfig, ag as FarmAuthSessionConfig, ah as FarmAuthUserConfig, g as FarmContextFactory, e as FarmContextFactoryInput, a$ as FarmDeployConfig, b1 as FarmDeployTarget, c$ as FarmDevtoolsConfig, d0 as FarmDevtoolsUserConfig, W as FarmIntegration, b2 as FarmIntegrationCategory, bl as FarmIntegrationConfigContext, bm as FarmIntegrationConfigDefinition, bn as FarmIntegrationConfigInput, bs as FarmIntegrationData, bC as FarmIntegrationDocumentNavigation, bU as FarmIntegrationEndpointValue, bV as FarmIntegrationEndpoints, bX as FarmIntegrationEndpointsFactory, bW as FarmIntegrationEndpointsFactoryContext, bt as FarmIntegrationHandlerContext, be as FarmIntegrationInputSchema, bq as FarmIntegrationLifecycleContext, br as FarmIntegrationLifecycleHook, bo as FarmIntegrationLifecycleLogLevel, bp as FarmIntegrationLifecycleLogger, bN as FarmIntegrationLogEvent, bM as FarmIntegrationLogPhase, bO as FarmIntegrationLogger, bz as FarmIntegrationMiddleware, cd as FarmIntegrationOrmClient, cc as FarmIntegrationOrmSchema, bB as FarmIntegrationProvider, bA as FarmIntegrationProviderProps, bg as FarmIntegrationRequestContextStore, bw as FarmIntegrationRoute, bk as FarmIntegrationRouteArgs, bi as FarmIntegrationRouteDb, bR as FarmIntegrationRouteFactory, bv as FarmIntegrationRouteHook, bu as FarmIntegrationRouteHookContext, b9 as FarmIntegrationRouteInput, bf as FarmIntegrationRouteInputSchemas, b7 as FarmIntegrationRouteInputSource, b6 as FarmIntegrationRouteMethod, by as FarmIntegrationRouteMiddleware, b4 as FarmIntegrationRouteParamValue, b5 as FarmIntegrationRouteParams, bj as FarmIntegrationRouteStorageArgs, bT as FarmIntegrationRoutesFactory, bS as FarmIntegrationRoutesFactoryContext, bK as FarmIntegrationSchema, bG as FarmIntegrationSchemaConstraint, bF as FarmIntegrationSchemaField, bD as FarmIntegrationSchemaFieldType, bH as FarmIntegrationSchemaModel, bI as FarmIntegrationSchemaModelExtension, bJ as FarmIntegrationSchemaModelOverride, bE as FarmIntegrationSchemaReference, b3 as FarmIntegrationSlot, bd as FarmIntegrationStandardValidationResult, bb as FarmIntegrationValidationErrorLike, ba as FarmIntegrationValidationIssue, b8 as FarmIntegrationValidationPathSegment, bc as FarmIntegrationValidationResult, bP as FarmIntegrationsUserConfig, ac as FarmLayerConfig, A as FarmLayerEntry, cN as FarmMarkdownPageModuleInput, cM as FarmMarkdownPageSource, cJ as FarmMdxComponent, cK as FarmMdxComponents, _ as FarmMdxResolvedConfig, cL as FarmMdxUserConfig, Y as FarmMiddlewareConfig, a as FarmMigrationCommand, b as FarmMigrationsConfig, c as FarmMigrationsUserConfig, V as FarmPlugin, aE as FarmPluginBuildHooks, aG as FarmPluginClientConfig, aj as FarmPluginContext, aF as FarmPluginDevHooks, aB as FarmPluginDiscoveredRoute, aD as FarmPluginRenderHooks, an as FarmPluginRouteRuntimePayload, aC as FarmPluginRouterHooks, at as FarmPluginRuntimeAfterEvent, aq as FarmPluginRuntimeBaseEvent, as as FarmPluginRuntimeBeforeEvent, aw as FarmPluginRuntimeCloseEvent, ar as FarmPluginRuntimeContextEvent, au as FarmPluginRuntimeErrorEvent, ax as FarmPluginRuntimeHooks, am as FarmPluginRuntimeKind, az as FarmPluginRuntimeRequestHandler, ay as FarmPluginRuntimeRequestOptions, aA as FarmPluginRuntimeSession, av as FarmPluginRuntimeStartEvent, ao as FarmPluginSetupContext, ap as FarmPluginStateContext, t as FarmRequest, ak as FarmRequestPluginContext, al as FarmRequestStore, u as FarmResponse, cD as FarmRouteRule, cC as FarmRouteRuleCors, cB as FarmRouteRuleRedirect, cA as FarmRouteRuleRenderMode, cE as FarmRouteRules, bx as FarmTypedIntegrationRoute, T as FarmUserConfig, aQ as HMRUpdatePayload, aW as HeaderConfig, aZ as I18nConfig, aY as ImageConfig, ch as InferFarmIntegrationOrmClient, ce as InferFarmIntegrationOrmField, cf as InferFarmIntegrationOrmFields, cg as InferFarmIntegrationOrmSchema, cm as IntegrationOrmModelNames, m as Layout, r as LayoutModule, k as LayoutProps, n as Loading, L as LoadingProps, s as Metadata, cs as MiddlewareChain, a_ as MiddlewareConfig, cn as MiddlewareContext, aJ as MiddlewareDiscoveredPayload, co as MiddlewareFunction, M as MiddlewareProps, cz as MiddlewareResult, cr as MiddlewareStore, cy as NextFunction, aS as NitroBuildLifecyclePayload, N as NitroPreset, l as Page, i as PageProps, j as PagePropsWithMiddleware, x as ParsedRoute, P as PluginContextProps, a3 as PluginManager, ai as PluginRequestContext, cv as RateLimitConfig, cx as RateLimitStatus, cw as RateLimitStorage, X as ReadonlyMiddlewareStore, aV as RedirectConfig, aN as RenderLifecyclePayload, cp as RequestMiddleware, cq as RequestMiddlewareContext, a0 as ResolvedFarmAuthConfig, aU as ResolvedFarmConfig, b0 as ResolvedFarmDeployConfig, $ as ResolvedFarmDevtoolsConfig, R as ResolvedFarmMigrationsConfig, aX as RewriteConfig, aH as RouteDiscoveredPayload, aL as RouteMatchPayload, aM as RouteMatchResultPayload, w as RouteSegment, aI as RoutesGeneratedPayload, v as ServerAction, aT as ShutdownPayload, q as StaticPathParams, S as StaticPathPrimitive, cU as createFarmMarkdownRouteModule, cV as createFarmMarkdownRouteModuleFromFile, cX as createFarmMarkdownSourceResponse, cj as createIntegrationOrm, bY as createIntegrationRoute, cT as createMarkdownMetadata, b$ as defineIntegration, bL as defineIntegrationSchema, a2 as definePlugin, cb as dispatchIntegrationRequest, cl as farmIntegrationSchemaToOrmSchema, aa as getDeployTargetForPreset, K as getFarmAppDirectories, bQ as getFarmIntegrationPluginServerRuntime, O as getFarmLayerAliases, J as getFarmSourceRoots, c3 as getIntegrationDocumentNavigationMatchers, c2 as getIntegrationProviders, c4 as getIntegrationSchemas, ab as getPresetForDeployTarget, ca as getRegisteredIntegrationAPIManifest, c5 as getRegisteredIntegrationRuntime, c7 as getRegisteredIntegrationSchemas, c6 as getRegisteredIntegrations, bZ as integrationRoute, c0 as isFarmIntegration, cP as isFarmMarkdownPageFile, a5 as loadConfig, cW as loadFarmMdxComponents, c8 as matchIntegrationRoute, c9 as matchRegisteredIntegrationRoute, a9 as normalizeDeployTarget, cQ as normalizeFarmMarkdownRoutePath, cF as normalizeRouteRules, cR as parseMarkdownFrontmatter, a4 as resolveConfig, a6 as resolveDeployConfig, a8 as resolveDeployOutputPath, d1 as resolveFarmDevtoolsConfig, I as resolveFarmLayers, ck as resolveIntegrationOrmRuntimeClient, c1 as resolveIntegrationPlugins, cO as resolveMdxConfig, a7 as resolveMigrationsConfig, cH as routeRulesToHeaders, cI as routeRulesToNitroRouteRules, cG as routeRulesToRedirects, cS as titleFromMarkdown } from './client-plugins-Bc5jHcNr.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-CA0z0c-2.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-DRGUmJ3s.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-udtobOLv.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, q as AnyEndpointMiddleware, D as DELETE, e as EndpointErrorContracts, E as EndpointErrorDefinition, d as EndpointErrorDefinitions, f as EndpointFail, g as EndpointFailure, v as EndpointHandler, s as EndpointInvalidationContext, r as EndpointInvalidationTarget, t as EndpointInvalidations, p as EndpointMiddleware, l as EndpointMiddlewareContext, o as EndpointMiddlewareResult, u as EndpointOptions, j as EndpointParamValue, k as EndpointParams, G as GET, H as HEAD, I as InferEndpointMiddlewareContext, O as OPTIONS, y as PATCH, P as POST, x as PUT, T as TypedEndpoint, w as createEndpoint, i as invokeAPIRouteEndpoint, h as isEndpointFailure, a as isWebResponse, m as matchAPIRoute, n as normalizeRouteResponse } from './runtime-DgeS2skB.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, createContext, farmMiddlewarePlugin, getFromMiddleware, getRateLimitStatus, hasMiddlewareData, 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-9KG7GuvW.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, d as FarmDocsSidebarItem, a as FarmDocsUserConfig } from './types-C9N-nk5R.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 { DEFAULT_FARM_WORKFLOW_DIRS, DEFAULT_FARM_WORKFLOW_ROUTE, DEFAULT_FARM_WORKFLOW_SECRET_ENV, FarmCronDefinition, FarmDiscoveredWorkflow, FarmWorkflowDefinition, FarmWorkflowHTTPHandlerOptions, FarmWorkflowLogger, FarmWorkflowRunContext, FarmWorkflowSchedule, FarmWorkflowsResolvedConfig, FarmWorkflowsUserConfig, PreparedFarmWorkflows, applyFarmWorkflowVercelCrons, createFarmWorkflowRequestHandler, createFarmWorkflowVercelCrons, defineCron, defineTask, defineWorkflow, discoverFarmWorkflows, prepareFarmWorkflowsForNitro, resolveWorkflowsConfig, runFarmWorkflowModule } from './workflows.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 { FarmEnvironment, FarmEnvironmentError, FarmIsomorphicFnOptions, createClientOnlyFn, createIsomorphicFn, createServerOnlyFn } from './environment.js';
+export { FarmFont, FarmFontDisplay, FarmFontOptions, FarmFontSource, LocalFontOptions, RemoteFontOptions, RemoteFontSource, localFont, remoteFont } 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, InferServerFnSchemaInput, InferServerFnSchemaOutput, ServerFn, ServerFnContext, ServerFnFormInput, ServerFnHandler, 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, createFarmDeploymentCookie, createFarmDeploymentMismatchError, createFarmDeploymentMismatchResponse, createFarmDeploymentRequestHeaders, getFarmDeploymentMismatch, 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 { F as FarmChunkRecoveryOptions, i as installChunkErrorRecovery, a as isChunkLoadError } from './production-runtime-DDEM1D2q.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';
+import 'http';
+import '@farming-labs/orm';
+import './metadata-JHn-8eht.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;
+}
+interface GenerateFarmTypeArtifactsResult {
+    typesPath?: string;
+    routeTypesPath?: string;
+    apiTypesPath?: string;
+    envTypesPath?: string;
+    imageTypesPath?: string;
+    i18nTypesPath?: string;
+    apiRoutes: APIRouteInfo[];
+}
+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 app directory for page files, generate RoutePath union type,
+ * and write a .d.ts file for typed Link href.
+ */
+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 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>;
+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>): 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, collectSSGPages, createFarmImageTypeDeclarations, generateFarmI18nTypes, generateFarmImageTypes, generateFarmTypeArtifacts, generateRouteTypes, generateSSGManifest, getRevalidateInterval, hasISR, hasPPR, isSSGModule, matchSSGPage, parseRouteRenderingDirective, resolveRouteRenderingConfig, resolveRouteRenderingConfigFromFile };

package/dist/index.mjs

@@ -9,7 +9,7 @@ import {
 } from "./chunk-VCANOYFI.mjs";
 import {
   build
-} from "./chunk-DTOWEQRV.mjs";
+} from "./chunk-4677KXB7.mjs";
 import "./chunk-SL6HTIOK.mjs";
 import "./chunk-4S3ORGFA.mjs";
 import {
@@ -152,7 +152,7 @@ import {
   parseRouteRenderingDirective,
   resolveRouteRenderingConfig,
   resolveRouteRenderingConfigFromFile
-} from "./chunk-E2AI2CW7.mjs";
+} from "./chunk-77BOAQHI.mjs";
 import {
   APITypeGenerator
 } from "./chunk-LGHEOHBU.mjs";
@@ -389,7 +389,7 @@ import {
   getCurrentRequest
 } from "./chunk-RHIFZZUI.mjs";
 import "./chunk-LM2YNO4U.mjs";
-import "./chunk-3QDB3IA6.mjs";
+import "./chunk-5EVQFRL2.mjs";
 import {
   SPARouter,
   getRouter,

package/dist/integration-api-CHT2OKAf.d.mts

@@ -0,0 +1,93 @@
+type FarmIntegrationAPIMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+type FarmIntegrationAPIBodyFormat = "json" | "form" | "none";
+type FarmIntegrationAPIResponseFormat = "json" | "text" | "response";
+interface FarmIntegrationAPIOperation<TBody = never, TQuery = never, TResponse = unknown, TServer extends boolean = false, TMethod extends FarmIntegrationAPIMethod = FarmIntegrationAPIMethod> {
+    readonly kind: "farm-integration-api-operation";
+    path: string;
+    method: TMethod;
+    bodyFormat?: FarmIntegrationAPIBodyFormat;
+    responseFormat?: FarmIntegrationAPIResponseFormat;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    isServer?: TServer;
+    __pathless?: boolean;
+    __types?: {
+        body: TBody;
+        query: TQuery;
+        response: TResponse;
+    };
+}
+type FarmIntegrationAPI = {
+    [key: string]: FarmIntegrationAPI | FarmIntegrationAPIOperation<any, any, any, any, any>;
+};
+type FarmIntegrationRouteOperationCarrier<TPath extends string = string, TOperation extends FarmIntegrationAPIOperation<any, any, any, any, any> = FarmIntegrationAPIOperation<any, any, any, any, any>> = {
+    path: TPath;
+    __operation: TOperation;
+};
+type IntegrationAPIBuilderOptions<TServer extends boolean = false> = Omit<FarmIntegrationAPIOperation<any, any, any, TServer>, "kind" | "method" | "path" | "__pathless" | "__types">;
+declare function defineIntegrationAPIOperation<TBody = never, TQuery = never, TResponse = unknown, TServer extends boolean = false, TMethod extends FarmIntegrationAPIMethod = FarmIntegrationAPIMethod>(operation: Omit<FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, TMethod>, "kind" | "__types">): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, TMethod>;
+declare function defineIntegrationAPI<TAPI extends FarmIntegrationAPI>(api: TAPI): TAPI;
+declare function get<TResponse = unknown, TServer extends boolean = false>(path: string, options?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, never, TResponse, TServer, "GET">;
+declare function get<TQuery = never, TResponse = unknown, TServer extends boolean = false>(path: string, options?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, TQuery, TResponse, TServer, "GET">;
+declare function get<TResponse = unknown, TServer extends boolean = false>(options?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, never, TResponse, TServer, "GET">;
+declare function get<TQuery = never, TResponse = unknown, TServer extends boolean = false>(options?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, TQuery, TResponse, TServer, "GET">;
+type RouteOperationsToAPI<TOperations extends readonly FarmIntegrationAPIOperation<any, any, any, any, any>[]> = {
+    [TMethod in Lowercase<TOperations[number]["method"] & string>]: Extract<TOperations[number], {
+        method: Uppercase<TMethod>;
+    }>;
+};
+type StripRouteClientPrefix<TPath extends string> = TPath extends `/api/${string}/${infer TRest}` ? TRest : TPath extends `/${string}/${infer TRest}` ? TRest : TPath extends `/${infer TRest}` ? TRest : TPath;
+type NormalizeRouteSegment<TSegment extends string> = TSegment extends `[...${infer TName}]` ? TName : TSegment extends `[${infer TName}]` ? TName : TSegment extends `${infer TName}(${string}` ? TName : CamelCaseRouteSegment<TSegment>;
+type CamelCaseRouteSegment<TSegment extends string> = TSegment extends `${infer THead}-${infer TTail}` ? `${THead}${Capitalize<CamelCaseRouteSegment<TTail>>}` : TSegment;
+type RouteNamespaceFromPath<TPath extends string, TOperation extends FarmIntegrationAPIOperation<any, any, any, any, any>> = TPath extends `${infer THead}/${infer TTail}` ? {
+    [TKey in NormalizeRouteSegment<THead>]: RouteNamespaceFromPath<TTail, TOperation>;
+} : {
+    [TKey in NormalizeRouteSegment<TPath>]: {
+        [TMethod in Lowercase<TOperation["method"] & string>]: TOperation;
+    };
+};
+type UnionToIntersection<TUnion> = (TUnion extends unknown ? (value: TUnion) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type ExpandRecursively<TValue> = TValue extends (...args: any[]) => any ? TValue : TValue extends object ? {
+    [TKey in keyof TValue]: ExpandRecursively<TValue[TKey]>;
+} : TValue;
+type RoutesToAPI<TRoutes extends readonly FarmIntegrationRouteOperationCarrier<string, any>[]> = ExpandRecursively<UnionToIntersection<TRoutes[number] extends FarmIntegrationRouteOperationCarrier<infer TPath, infer TOperation> ? RouteNamespaceFromPath<StripRouteClientPrefix<TPath>, TOperation> : never>>;
+type InferIntegrationAPIFromRoutes<TRoutes extends readonly FarmIntegrationRouteOperationCarrier<string, any>[]> = RoutesToAPI<TRoutes>;
+declare function route<TAPI extends FarmIntegrationAPI>(path: string, definition: TAPI): TAPI;
+declare function route<TOperations extends readonly FarmIntegrationAPIOperation<any, any, any, any, any>[]>(path: string, ...operations: TOperations): RouteOperationsToAPI<TOperations>;
+declare function fromRoutes<TRoutes extends readonly FarmIntegrationRouteOperationCarrier<string, any>[]>(routes: TRoutes): RoutesToAPI<TRoutes>;
+declare const api: {
+    get: typeof get;
+    route: typeof route;
+    fromRoutes: typeof fromRoutes;
+    post<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "POST">;
+    put<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PUT">;
+    patch<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PATCH">;
+    delete<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "DELETE">;
+    options<TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, TQuery, TResponse, TServer, "OPTIONS">;
+    head<TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, TQuery, TResponse, TServer, "HEAD">;
+    form: {
+        post<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "POST">;
+        put<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PUT">;
+        patch<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PATCH">;
+        delete<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "DELETE">;
+    };
+};
+declare const endpoint: {
+    get: typeof get;
+    route: typeof route;
+    fromRoutes: typeof fromRoutes;
+    post<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "POST">;
+    put<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PUT">;
+    patch<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PATCH">;
+    delete<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "DELETE">;
+    options<TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, TQuery, TResponse, TServer, "OPTIONS">;
+    head<TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<never, TQuery, TResponse, TServer, "HEAD">;
+    form: {
+        post<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "POST">;
+        put<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PUT">;
+        patch<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "PATCH">;
+        delete<TBody = never, TResponse = unknown, TQuery = never, TServer extends boolean = false>(pathOrOptions?: string | IntegrationAPIBuilderOptions<TServer>, maybeOptions?: IntegrationAPIBuilderOptions<TServer>): FarmIntegrationAPIOperation<TBody, TQuery, TResponse, TServer, "DELETE">;
+    };
+};
+
+export { type FarmIntegrationAPI as F, type InferIntegrationAPIFromRoutes as I, type FarmIntegrationAPIOperation as a, api as b, defineIntegrationAPIOperation as c, defineIntegrationAPI as d, type FarmIntegrationAPIBodyFormat as e, type FarmIntegrationAPIMethod as f, type FarmIntegrationAPIResponseFormat as g, type FarmIntegrationRouteOperationCarrier as h, endpoint as i };