import { a as ServerSidePropsResult, c as clearPropsCacheForComponent, d as extractServerPropsWithCache, f as extractStaticParams, i as MetadataResult, l as extractMetadata, n as ServerCacheControlConfig, o as StaticParamsResult, p as hasServerSideDataFetching, r as ServerConfig, s as clearPropsCache, t as ServerCSPConfig, u as extractServerProps } from "./server-config-D7_4Hk9w.mjs";
import { a as ErrorProps, c as LayoutEntry, d as Metadata, f as NotFoundEntry, g as TemplateEntry, h as RouteSegmentType, i as ErrorEntry, l as LayoutProps, m as RouteSegment, n as AppRouteManifest, o as GenerateMetadata, p as PageProps, r as AppRouteMatch, s as GenerateStaticParams, t as AppRouteEntry, u as LoadingEntry } from "./types-BwhW3M72.mjs";
import { a as Sitemap, c as SitemapVideo, i as RobotsRule, o as SitemapEntry, r as Robots, s as SitemapImage } from "./metadata-route-_d5FkjlL.mjs";
import { a as ProxyModule, c as RariURL, i as ProxyMatcher, l as RequestCookies, n as ProxyConfig, o as ProxyResult, r as ProxyFunction, s as RariFetchEvent, t as CookieOptions, u as ResponseCookies } from "./types-3dq9RGI5.mjs";
import { RariRequest } from "./proxy/RariRequest.mjs";
import { RariResponse } from "./proxy/RariResponse.mjs";
import { Plugin, UserConfig } from "vite-plus";

//#region src/proxy/vite-plugin.d.ts
interface ProxyPluginOptions {
  root?: string;
  srcDir?: string;
  proxyFileName?: string;
  extensions?: string[];
  verbose?: boolean;
}
declare function rariProxy(options?: ProxyPluginOptions): Plugin;
//#endregion
//#region src/vite/server-build.d.ts
interface ServerBuildOptions {
  outDir?: string;
  rscDir?: string;
  manifestPath?: string;
  serverConfigPath?: string;
  minify?: boolean;
  alias?: Record<string, string>;
  define?: Record<string, string>;
  csp?: ServerCSPConfig;
  cacheControl?: ServerCacheControlConfig;
}
//#endregion
//#region src/vite/index.d.ts
interface RouterPluginOptions {
  appDir?: string;
  extensions?: string[];
}
interface RariOptions {
  projectRoot?: string;
  serverBuild?: ServerBuildOptions;
  serverHandler?: boolean;
  proxy?: ProxyPluginOptions | false;
  router?: RouterPluginOptions | false;
  images?: {
    remotePatterns?: Array<{
      protocol?: 'http' | 'https';
      hostname: string;
      port?: string;
      pathname?: string;
      search?: string;
    }>;
    localPatterns?: Array<{
      pathname: string;
      search?: string;
    }>;
    deviceSizes?: number[];
    imageSizes?: number[];
    formats?: ('avif' | 'webp')[];
    qualityAllowlist?: number[];
    minimumCacheTTL?: number;
    maxCacheSize?: number;
  };
  csp?: {
    scriptSrc?: string[];
    styleSrc?: string[];
    imgSrc?: string[];
    fontSrc?: string[];
    connectSrc?: string[];
    defaultSrc?: string[];
    workerSrc?: string[];
  };
  cacheControl?: {
    routes: Record<string, string>;
  };
}
declare function defineRariOptions(config: RariOptions): RariOptions;
declare function rari$1(options?: RariOptions): Plugin[];
declare function defineRariConfig(config: UserConfig & {
  plugins?: Plugin[];
}): UserConfig;
//#endregion
//#region src/api-routes.d.ts
interface RouteContext<TParams extends Record<string, string> = Record<string, string>> {
  params: TParams;
}
type RouteHandler<TParams extends Record<string, string> = Record<string, string>> = (request: Request, context?: RouteContext<TParams>) => Response | Promise<Response> | any | Promise<any>;
interface ApiRouteHandlers<TParams extends Record<string, string> = Record<string, string>> {
  GET?: RouteHandler<TParams>;
  POST?: RouteHandler<TParams>;
  PUT?: RouteHandler<TParams>;
  DELETE?: RouteHandler<TParams>;
  PATCH?: RouteHandler<TParams>;
  HEAD?: RouteHandler<TParams>;
  OPTIONS?: RouteHandler<TParams>;
}
declare class ApiResponse extends Response {
  static json(data: any, init?: ResponseInit): Response;
  static redirect(url: string, status?: number): Response;
  static noContent(init?: ResponseInit): Response;
}
//#endregion
//#region src/http-runtime-client.d.ts
interface RuntimeClient {
  initialize: () => Promise<void>;
  registerComponent: (componentId: string, componentCode: string) => Promise<void>;
  renderToStreamCallbacks: (componentId: string, props?: string) => Promise<any>;
  registerClientComponent: (componentId: string, filePath: string, exportName: string) => void;
  registerClientReference: (referenceId: string, filePath: string, exportName: string) => void;
  listComponents: () => string[];
  shutdown: () => Promise<void>;
}
interface HealthResponse {
  status: string;
  timestamp: string;
}
declare class HttpRuntimeClient implements RuntimeClient {
  private baseUrl;
  private timeout;
  private components;
  private initialized;
  constructor(options?: {
    host?: string;
    port?: number;
    timeout?: number;
    ssl?: boolean;
  });
  private assertInitialized;
  private request;
  initialize(): Promise<void>;
  registerComponent(componentId: string, componentCode: string): Promise<void>;
  renderToStreamCallbacks(componentId: string, props?: string): Promise<any>;
  registerClientComponent(componentId: string, filePath: string, exportName: string): void;
  private queueClientComponentRegistration;
  registerClientReference(referenceId: string, filePath: string, exportName: string): void;
  listComponents(): string[];
  shutdown(): Promise<void>;
  checkHealth(): Promise<HealthResponse>;
  isInitialized(): boolean;
  getBaseUrl(): string;
}
declare function createHttpRuntimeClient(options?: {
  host?: string;
  port?: number;
  timeout?: number;
  ssl?: boolean;
}): RuntimeClient;
//#endregion
//#region src/router/routes.d.ts
interface AppRouteGeneratorOptions {
  appDir: string;
  extensions?: string[];
  verbose?: boolean;
}
declare function generateAppRouteManifest(appDir: string, options?: Partial<AppRouteGeneratorOptions>): Promise<AppRouteManifest>;
//#endregion
//#region src/router/vite-plugin.d.ts
interface RariRouterPluginOptions {
  appDir?: string;
  extensions?: string[];
  outDir?: string;
}
declare function rariRouter(options?: RariRouterPluginOptions): Plugin;
//#endregion
//#region src/vite.d.ts
type Request$1 = globalThis.Request;
type Response$1 = globalThis.Response;
declare function rari(options?: Parameters<typeof rari$1>[0]): any[];
//#endregion
export { ApiResponse, type ApiRouteHandlers, type AppRouteEntry, type AppRouteManifest, type AppRouteMatch, type CookieOptions, type ErrorEntry, type ErrorProps, type GenerateMetadata, type GenerateStaticParams, HttpRuntimeClient, type LayoutEntry, type LayoutProps, type LoadingEntry, type Metadata, type MetadataResult, type NotFoundEntry, type PageProps, type ProxyConfig, type ProxyFunction, type ProxyMatcher, type ProxyModule, type ProxyPluginOptions, type ProxyResult, type RariFetchEvent, RariRequest, RariResponse, type RariURL, Request$1 as Request, type RequestCookies, Response$1 as Response, type ResponseCookies, type Robots, type RobotsRule, type RouteContext, type RouteHandler, type RouteSegment, type RouteSegmentType, type RuntimeClient, type ServerCSPConfig, type ServerConfig, type ServerSidePropsResult, type Sitemap, type SitemapEntry, type SitemapImage, type SitemapVideo, type StaticParamsResult, type TemplateEntry, clearPropsCache, clearPropsCacheForComponent, createHttpRuntimeClient, defineRariConfig, defineRariOptions, extractMetadata, extractServerProps, extractServerPropsWithCache, extractStaticParams, generateAppRouteManifest, hasServerSideDataFetching, rari, rariProxy, rariRouter };