acrylblends 0.7.3 → 0.7.4

package/lib/bun.d.ts

@@ -0,0 +1,75 @@
+import { L as MiddlewareHandler, t as Context, v as Env } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { f as FileSystemModule, m as ToSSGAdaptorInterface } from "./index-DaJtL7ci.js";
+import { a as WSEvents, n as UpgradeWebSocket } from "./index-BvFh1Gfx.js";
+import { t as ServeStaticOptions } from "./index-CseujaYI.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/bun/serve-static.d.ts
+declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/ssg.d.ts
+/**
+ * @experimental
+ * `bunFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+declare const bunFileSystemModule: FileSystemModule;
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const toSSG: ToSSGAdaptorInterface;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/websocket.d.ts
+/**
+ * @internal
+ */
+interface BunServerWebSocket<T> {
+  send(data: string | ArrayBuffer | Uint8Array, compress?: boolean): void;
+  close(code?: number, reason?: string): void;
+  data: T;
+  readyState: 0 | 1 | 2 | 3;
+}
+interface BunWebSocketHandler<T> {
+  open(ws: BunServerWebSocket<T>): void;
+  close(ws: BunServerWebSocket<T>, code?: number, reason?: string): void;
+  message(ws: BunServerWebSocket<T>, message: string | {
+    buffer: ArrayBufferLike;
+  }): void;
+}
+interface CreateWebSocket<T> {
+  upgradeWebSocket: UpgradeWebSocket<T>;
+  websocket: BunWebSocketHandler<BunWebSocketData>;
+}
+interface BunWebSocketData {
+  events: WSEvents;
+  url: URL;
+  protocol: string;
+}
+declare const upgradeWebSocket: UpgradeWebSocket<any>;
+declare const websocket: BunWebSocketHandler<BunWebSocketData>;
+/**
+ * @deprecated Import `upgradeWebSocket` and `websocket` directly from `acryl-router/bun` instead.
+ * @returns A function to create a Bun WebSocket handler.
+ */
+declare const createBunWebSocket: <T>() => CreateWebSocket<T>;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/conninfo.d.ts
+/**
+ * Get ConnInfo with Bun
+ * @param c Context
+ * @returns ConnInfo
+ */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/server.d.ts
+/**
+ * Get Bun Server Object from Context
+ * @template T - The type of Bun Server
+ * @param c Context
+ * @returns Bun Server
+ */
+declare const getBunServer: <T>(c: Context) => T | undefined;
+//#endregion
+export { type BunWebSocketData, type BunWebSocketHandler, bunFileSystemModule, createBunWebSocket, getBunServer, getConnInfo, serveStatic, toSSG, upgradeWebSocket, websocket };

package/lib/bun.js

@@ -0,0 +1,134 @@
+import { t as serveStatic$1 } from "./serve-static-Cp5adzGo.js";
+import { c as toSSG$1 } from "./ssg-BwjcA-Ge.js";
+import { WSContext, createWSMessageEvent, defineWebSocketHelper } from "./ws.js";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+//#region ../../plugins/acryl-router/src/core/adapter/bun/serve-static.ts
+const serveStatic = (options = {}) => {
+	return async function serveStatic(c, next) {
+		const getContent = async (path) => {
+			const file = Bun.file(path);
+			return await file.exists() ? file : null;
+		};
+		const isDir = async (path) => {
+			let isDir;
+			try {
+				isDir = (await stat(path)).isDirectory();
+			} catch {}
+			return isDir;
+		};
+		return serveStatic$1({
+			...options,
+			getContent,
+			join,
+			isDir
+		})(c, next);
+	};
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/ssg.ts
+/**
+* @experimental
+* `bunFileSystemModule` is an experimental feature.
+* The API might be changed.
+*/
+const bunFileSystemModule = {
+	writeFile: async (path, data) => {
+		await Bun.write(path, data);
+	},
+	mkdir: async () => {}
+};
+/**
+* @experimental
+* `toSSG` is an experimental feature.
+* The API might be changed.
+*/
+const toSSG = async (app, options) => {
+	return toSSG$1(app, bunFileSystemModule, options);
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/server.ts
+/**
+* Get Bun Server Object from Context
+* @template T - The type of Bun Server
+* @param c Context
+* @returns Bun Server
+*/
+const getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/websocket.ts
+/**
+* @internal
+*/
+const createWSContext = (ws) => {
+	return new WSContext({
+		send: (source, options) => {
+			ws.send(source, options?.compress);
+		},
+		raw: ws,
+		readyState: ws.readyState,
+		url: ws.data.url,
+		protocol: ws.data.protocol,
+		close(code, reason) {
+			ws.close(code, reason);
+		}
+	});
+};
+const upgradeWebSocket = defineWebSocketHelper((c, events) => {
+	const server = getBunServer(c);
+	if (!server) throw new TypeError("env has to include the 2nd argument of fetch.");
+	if (server.upgrade(c.req.raw, { data: {
+		events,
+		url: new URL(c.req.url),
+		protocol: c.req.header("sec-websocket-protocol")?.split(",")[0]?.trim() ?? ""
+	} })) return new Response(null);
+});
+const websocket = {
+	open(ws) {
+		const websocketListeners = ws.data.events;
+		if (websocketListeners.onOpen) websocketListeners.onOpen(new Event("open"), createWSContext(ws));
+	},
+	close(ws, code, reason) {
+		const websocketListeners = ws.data.events;
+		if (websocketListeners.onClose) websocketListeners.onClose(new CloseEvent("close", {
+			code,
+			reason
+		}), createWSContext(ws));
+	},
+	message(ws, message) {
+		const websocketListeners = ws.data.events;
+		if (websocketListeners.onMessage) {
+			const normalizedReceiveData = typeof message === "string" ? message : message.buffer;
+			websocketListeners.onMessage(createWSMessageEvent(normalizedReceiveData), createWSContext(ws));
+		}
+	}
+};
+/**
+* @deprecated Import `upgradeWebSocket` and `websocket` directly from `acryl-router/bun` instead.
+* @returns A function to create a Bun WebSocket handler.
+*/
+const createBunWebSocket = () => ({
+	upgradeWebSocket,
+	websocket
+});
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/conninfo.ts
+/**
+* Get ConnInfo with Bun
+* @param c Context
+* @returns ConnInfo
+*/
+const getConnInfo = (c) => {
+	const server = getBunServer(c);
+	if (!server) throw new TypeError("env has to include the 2nd argument of fetch.");
+	if (typeof server.requestIP !== "function") throw new TypeError("server.requestIP is not a function.");
+	const info = server.requestIP(c.req.raw);
+	if (!info) return { remote: {} };
+	return { remote: {
+		address: info.address,
+		addressType: info.family === "IPv6" || info.family === "IPv4" ? info.family : void 0,
+		port: info.port
+	} };
+};
+//#endregion
+export { bunFileSystemModule, createBunWebSocket, getBunServer, getConnInfo, serveStatic, toSSG, upgradeWebSocket, websocket };

package/lib/cloudflare-pages.d.ts

@@ -0,0 +1,58 @@
+import { L as MiddlewareHandler, Y as Schema, g as BlankSchema, j as Input, v as Env } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/handler.d.ts
+type Params<P extends string = any> = Record<P, string | string[]>;
+type EventContext<Env = {}, P extends string = any, Data = Record<string, unknown>> = {
+  request: Request;
+  functionPath: string;
+  waitUntil: (promise: Promise<unknown>) => void;
+  passThroughOnException: () => void;
+  props: any;
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
+  env: Env & {
+    ASSETS: {
+      fetch: typeof fetch;
+    };
+  };
+  params: Params<P>;
+  data: Data;
+};
+declare type PagesFunction<Env = unknown, Params extends string = any, Data extends Record<string, unknown> = Record<string, unknown>> = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>;
+declare const handle: <E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/">(app: Acryl<E, S, BasePath>) => PagesFunction<E["Bindings"]>;
+declare function handleMiddleware<E extends Env = {}, P extends string = any, I extends Input = {}>(middleware: MiddlewareHandler<E & {
+  Bindings: {
+    eventContext: EventContext;
+  };
+}, P, I>): PagesFunction<E['Bindings']>;
+/**
+ *
+ * @description `serveStatic()` is for advanced mode:
+ * https://developers.cloudflare.com/pages/platform/functions/advanced-mode/#set-up-a-function
+ */
+declare const serveStatic: () => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/conninfo.d.ts
+/**
+ * Get connection information from Cloudflare Pages
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * import { handle, getConnInfo } from 'acrylblends/cloudflare-pages'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export const onRequest = handle(app)
+ * ```
+ */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { type EventContext, getConnInfo, handle, handleMiddleware, serveStatic };

package/lib/cloudflare-pages.js

@@ -0,0 +1,78 @@
+import { HTTPException } from "./http-exception.js";
+import { t as Context } from "./context-DDO0cfuP.js";
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/handler.ts
+const handle = (app) => (eventContext) => {
+	return app.fetch(eventContext.request, {
+		...eventContext.env,
+		eventContext
+	}, {
+		waitUntil: eventContext.waitUntil,
+		passThroughOnException: eventContext.passThroughOnException,
+		props: {}
+	});
+};
+function handleMiddleware(middleware) {
+	return async (executionCtx) => {
+		const context = new Context(executionCtx.request, {
+			env: {
+				...executionCtx.env,
+				eventContext: executionCtx
+			},
+			executionCtx
+		});
+		let response = void 0;
+		try {
+			response = await middleware(context, async () => {
+				try {
+					context.res = await executionCtx.next();
+				} catch (error) {
+					if (error instanceof Error) context.error = error;
+					else throw error;
+				}
+			});
+		} catch (error) {
+			if (error instanceof Error) context.error = error;
+			else throw error;
+		}
+		if (response) return response;
+		if (context.error instanceof HTTPException) return context.error.getResponse();
+		if (context.error) throw context.error;
+		return context.res;
+	};
+}
+/**
+*
+* @description `serveStatic()` is for advanced mode:
+* https://developers.cloudflare.com/pages/platform/functions/advanced-mode/#set-up-a-function
+*/
+const serveStatic = () => {
+	return async (c) => {
+		const res = await c.env.ASSETS.fetch(c.req.raw);
+		if (res.status === 404) return c.notFound();
+		return res;
+	};
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/conninfo.ts
+/**
+* Get connection information from Cloudflare Pages
+* @param c - Context
+* @returns Connection information including remote address
+* @example
+* ```ts
+* import { Acryl } from 'acrylblends'
+* import { handle, getConnInfo } from 'acrylblends/cloudflare-pages'
+*
+* const app = new Acryl()
+*
+* app.get('/', (c) => {
+*   const info = getConnInfo(c)
+*   return c.text(`Your IP: ${info.remote.address}`)
+* })
+*
+* export const onRequest = handle(app)
+* ```
+*/
+const getConnInfo = (c) => ({ remote: { address: c.req.header("cf-connecting-ip") } });
+//#endregion
+export { getConnInfo, handle, handleMiddleware, serveStatic };

package/lib/cloudflare-workers.d.ts

@@ -0,0 +1,21 @@
+import { L as MiddlewareHandler, v as Env } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { a as WSEvents, n as UpgradeWebSocket } from "./index-BvFh1Gfx.js";
+import { t as ServeStaticOptions$1 } from "./index-CseujaYI.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static.d.ts
+type ServeStaticOptions<E extends Env = Env> = ServeStaticOptions$1<E> & {
+  namespace?: unknown;
+  manifest?: object | string;
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static-module.d.ts
+declare const module: <E extends Env = Env>(options: Omit<ServeStaticOptions<E>, "namespace">) => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/websocket.d.ts
+declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, any, Omit<WSEvents<WebSocket>, 'onOpen'>>;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/conninfo.d.ts
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { getConnInfo, module as serveStatic, upgradeWebSocket };

package/lib/cloudflare-workers.js

@@ -0,0 +1,80 @@
+import { t as serveStatic$1 } from "./serve-static-Cp5adzGo.js";
+import { WSContext, defineWebSocketHelper } from "./ws.js";
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/utils.ts
+const getContentFromKVAsset = async (path, options) => {
+	let ASSET_MANIFEST;
+	if (options && options.manifest) if (typeof options.manifest === "string") ASSET_MANIFEST = JSON.parse(options.manifest);
+	else ASSET_MANIFEST = options.manifest;
+	else if (typeof __STATIC_CONTENT_MANIFEST === "string") ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
+	else ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
+	let ASSET_NAMESPACE;
+	if (options && options.namespace) ASSET_NAMESPACE = options.namespace;
+	else ASSET_NAMESPACE = __STATIC_CONTENT;
+	const key = ASSET_MANIFEST[path];
+	if (!key) return null;
+	const content = await ASSET_NAMESPACE.get(key, { type: "stream" });
+	if (!content) return null;
+	return content;
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static.ts
+/**
+* @deprecated
+* `serveStatic` in the Cloudflare Workers adapter is deprecated.
+* You can serve static files directly using Cloudflare Static Assets.
+* @see https://developers.cloudflare.com/workers/static-assets/
+* Cloudflare Static Assets is currently in open beta. If this doesn't work for you,
+* please consider using Cloudflare Pages.
+*/
+const serveStatic = (options = {}) => {
+	return async function serveStatic(c, next) {
+		const getContent = async (path) => {
+			return getContentFromKVAsset(path, {
+				manifest: options.manifest,
+				namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : void 0
+			});
+		};
+		return serveStatic$1({
+			...options,
+			getContent
+		})(c, next);
+	};
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static-module.ts
+const module = (options) => {
+	return serveStatic(options);
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/websocket.ts
+const upgradeWebSocket = defineWebSocketHelper(async (c, events) => {
+	if (c.req.header("Upgrade") !== "websocket") return;
+	const webSocketPair = new WebSocketPair();
+	const client = webSocketPair[0];
+	const server = webSocketPair[1];
+	const wsContext = new WSContext({
+		close: (code, reason) => server.close(code, reason),
+		get protocol() {
+			return server.protocol;
+		},
+		raw: server,
+		get readyState() {
+			return server.readyState;
+		},
+		url: server.url ? new URL(server.url) : null,
+		send: (source) => server.send(source)
+	});
+	if (events.onClose) server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+	if (events.onMessage) server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+	if (events.onError) server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+	server.accept?.();
+	return new Response(null, {
+		status: 101,
+		webSocket: client
+	});
+});
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/conninfo.ts
+const getConnInfo = (c) => ({ remote: { address: c.req.header("cf-connecting-ip") } });
+//#endregion
+export { getConnInfo, module as serveStatic, upgradeWebSocket };

package/lib/index-CseujaYI.d.ts

@@ -0,0 +1,31 @@
+import { L as MiddlewareHandler, i as Data, t as Context, v as Env } from "./context-DS3fYyG-.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/serve-static/index.d.ts
+type ServeStaticOptions<E extends Env = Env> = {
+  root?: string;
+  path?: string;
+  precompressed?: boolean; /** Allow percent signs in the routed request path. Defaults to false. */
+  allowPercentInPath?: boolean;
+  mimes?: Record<string, string>;
+  rewriteRequestPath?: (path: string) => string;
+  onFound?: (path: string, c: Context<E>) => void | Promise<void>;
+  onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
+};
+/**
+ * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
+ */
+declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
+  getContent: (path: string, c: Context<E>) => Promise<Data | Response | null>;
+  /**
+   *
+   * `join` option according to the runtime. Example `import { join } from 'node:path`. If not specified, it will fall back to the default join function.`
+   */
+  join?: (...paths: string[]) => string;
+  /**
+   * @deprecated Currently, `pathResolve` is no longer used.
+   */
+  pathResolve?: (path: string) => string;
+  isDir?: (path: string) => boolean | undefined | Promise<boolean | undefined>;
+}) => MiddlewareHandler;
+//#endregion
+export { serveStatic as n, ServeStaticOptions as t };

package/lib/index-DaJtL7ci.d.ts

@@ -0,0 +1,156 @@
+import { L as MiddlewareHandler, Y as Schema, t as Context, v as Env } from "./context-DS3fYyG-.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/ssg/ssg.d.ts
+declare const DEFAULT_OUTPUT_DIR = "./static";
+/**
+ * @experimental
+ * `FileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+interface FileSystemModule {
+  writeFile(path: string, data: string | Uint8Array): Promise<void>;
+  mkdir(path: string, options: {
+    recursive: boolean;
+  }): Promise<void | string>;
+}
+/**
+ * @experimental
+ * `ToSSGResult` is an experimental feature.
+ * The API might be changed.
+ */
+interface ToSSGResult {
+  success: boolean;
+  files: string[];
+  error?: Error;
+}
+declare const defaultExtensionMap: Record<string, string>;
+type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>;
+type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>;
+type AfterGenerateHook = (result: ToSSGResult, fsModule: FileSystemModule, options?: ToSSGOptions) => void | Promise<void>;
+declare const combineBeforeRequestHooks: (hooks: BeforeRequestHook | BeforeRequestHook[]) => BeforeRequestHook;
+declare const combineAfterResponseHooks: (hooks: AfterResponseHook | AfterResponseHook[]) => AfterResponseHook;
+declare const combineAfterGenerateHooks: (hooks: AfterGenerateHook | AfterGenerateHook[], fsModule: FileSystemModule, options?: ToSSGOptions) => AfterGenerateHook;
+interface SSGPlugin {
+  beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+  afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+  afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
+}
+interface ToSSGOptions {
+  dir?: string;
+  /**
+   * @deprecated Use plugins[].beforeRequestHook instead.
+   */
+  beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+  /**
+   * @deprecated Use plugins[].afterResponseHook instead.
+   */
+  afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+  /**
+   * @deprecated Use plugins[].afterGenerateHook instead.
+   */
+  afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
+  concurrency?: number;
+  extensionMap?: Record<string, string>;
+  plugins?: SSGPlugin[];
+}
+/**
+ * @experimental
+ * `fetchRoutesContent` is an experimental feature.
+ * The API might be changed.
+ */
+declare const fetchRoutesContent: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Acryl<E, S, BasePath>, beforeRequestHook?: BeforeRequestHook, afterResponseHook?: AfterResponseHook, concurrency?: number) => Generator<Promise<Generator<Promise<{
+  routePath: string;
+  mimeType: string;
+  content: string | ArrayBuffer;
+} | undefined>> | undefined>>;
+declare const saveContentToFile: (data: Promise<{
+  routePath: string;
+  content: string | ArrayBuffer;
+  mimeType: string;
+} | undefined>, fsModule: FileSystemModule, outDir: string, extensionMap?: Record<string, string>) => Promise<string | undefined>;
+/**
+ * @experimental
+ * `ToSSGInterface` is an experimental feature.
+ * The API might be changed.
+ */
+interface ToSSGInterface {
+  (app: Acryl<any, any, any>, fsModule: FileSystemModule, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `ToSSGAdaptorInterface` is an experimental feature.
+ * The API might be changed.
+ */
+interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+  (app: Acryl<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const toSSG: ToSSGInterface;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/helper/ssg/middleware.d.ts
+declare const X_ACRYL_DISABLE_SSG_HEADER_KEY = "x-acryl-disable-ssg";
+interface SSGParam {
+  [key: string]: string;
+}
+type SSGParams = SSGParam[];
+interface SSGParamsMiddleware {
+  <E extends Env = Env>(generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>): MiddlewareHandler<E>;
+  <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>;
+}
+/**
+ * Define SSG Route
+ */
+declare const ssgParams: SSGParamsMiddleware;
+/**
+ * @experimental
+ * `isSSGContext` is an experimental feature.
+ * The API might be changed.
+ */
+declare const isSSGContext: (c: Context) => boolean;
+/**
+ * @experimental
+ * `disableSSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const disableSSG: () => MiddlewareHandler;
+/**
+ * @experimental
+ * `onlySSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const onlySSG: () => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/helper/ssg/plugins.d.ts
+/**
+ * The default plugin that defines the recommended behavior.
+ *
+ * @experimental
+ * `defaultPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+declare const defaultPlugin: () => SSGPlugin;
+/**
+ * The redirect plugin that generates HTML redirect pages for HTTP redirect responses for status codes 301, 302, 303, 307 and 308.
+ *
+ * When used with `defaultPlugin`, place `redirectPlugin` before it, because `defaultPlugin` skips non-200 responses.
+ *
+ * ```ts
+ * // ✅ Will work as expected
+ * toSSG(app, fs, { plugins: [redirectPlugin(), defaultPlugin()] })
+ *
+ * // ❌ Will not work as expected
+ * toSSG(app, fs, { plugins: [defaultPlugin(), redirectPlugin()] })
+ * ```
+ *
+ * @experimental
+ * `redirectPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+declare const redirectPlugin: () => SSGPlugin;
+//#endregion
+export { saveContentToFile as C, fetchRoutesContent as S, ToSSGResult as _, isSSGContext as a, combineBeforeRequestHooks as b, AfterGenerateHook as c, DEFAULT_OUTPUT_DIR as d, FileSystemModule as f, ToSSGOptions as g, ToSSGInterface as h, disableSSG as i, AfterResponseHook as l, ToSSGAdaptorInterface as m, redirectPlugin as n, onlySSG as o, SSGPlugin as p, X_ACRYL_DISABLE_SSG_HEADER_KEY as r, ssgParams as s, defaultPlugin as t, BeforeRequestHook as u, combineAfterGenerateHooks as v, toSSG as w, defaultExtensionMap as x, combineAfterResponseHooks as y };