@ecopages/core 0.2.0-alpha.1

package/src/adapters/node/static-content-server.js

@@ -0,0 +1,166 @@
+import { createServer } from "node:http";
+import { extname, join, normalize, sep } from "node:path";
+import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT, STATUS_MESSAGE } from "../../constants.js";
+import { fileSystem } from "@ecopages/file-system";
+import { ServerUtils } from "../../utils/server-utils.module.js";
+class NodeStaticContentServer {
+  appConfig;
+  options;
+  server = null;
+  constructor({ appConfig, options }) {
+    this.appConfig = appConfig;
+    this.options = {
+      hostname: options?.hostname ?? DEFAULT_ECOPAGES_HOSTNAME,
+      port: options?.port ?? DEFAULT_ECOPAGES_PORT
+    };
+  }
+  shouldServeGzip(contentType) {
+    return ["text/javascript", "text/css"].includes(contentType);
+  }
+  sanitizePath(pathname) {
+    const withoutLeadingSlash = pathname.replace(/^\/+/, "");
+    const normalizedPath = normalize(withoutLeadingSlash);
+    if (normalizedPath.startsWith("..") || normalizedPath.includes(`..${sep}`)) {
+      return null;
+    }
+    return normalizedPath;
+  }
+  sendResponse(res, status, headers, body) {
+    res.statusCode = status;
+    for (const [key, value] of Object.entries(headers)) {
+      res.setHeader(key, value);
+    }
+    if (!body) {
+      res.end();
+      return;
+    }
+    res.end(body);
+  }
+  sendNotFoundPage(req, res) {
+    const error404TemplatePath = join(this.appConfig.absolutePaths.distDir, "404.html");
+    const isHead = (req.method ?? "GET").toUpperCase() === "HEAD";
+    if (!fileSystem.exists(error404TemplatePath)) {
+      this.sendResponse(
+        res,
+        404,
+        { "Content-Type": "text/plain" },
+        isHead ? void 0 : Buffer.from(STATUS_MESSAGE[404])
+      );
+      return;
+    }
+    const file = fileSystem.readFileAsBuffer(error404TemplatePath);
+    this.sendResponse(res, 404, { "Content-Type": "text/html" }, isHead ? void 0 : file);
+  }
+  serveFile(req, res, filePath, status = 200) {
+    const contentType = ServerUtils.getContentType(extname(filePath));
+    const acceptsGzip = req.headers["accept-encoding"]?.includes("gzip");
+    const isHead = (req.method ?? "GET").toUpperCase() === "HEAD";
+    if (acceptsGzip && this.shouldServeGzip(contentType)) {
+      const gzipPath = `${filePath}.gz`;
+      if (fileSystem.exists(gzipPath)) {
+        const file2 = fileSystem.readFileAsBuffer(gzipPath);
+        this.sendResponse(
+          res,
+          status,
+          {
+            "Content-Type": contentType,
+            "Content-Encoding": "gzip",
+            Vary: "Accept-Encoding"
+          },
+          isHead ? void 0 : file2
+        );
+        return;
+      }
+    }
+    if (!fileSystem.exists(filePath)) {
+      this.sendNotFoundPage(req, res);
+      return;
+    }
+    const file = fileSystem.readFileAsBuffer(filePath);
+    this.sendResponse(res, status, { "Content-Type": contentType }, isHead ? void 0 : file);
+  }
+  handleRequest(req, res) {
+    const method = (req.method ?? "GET").toUpperCase();
+    const isHead = method === "HEAD";
+    if (method !== "GET" && method !== "HEAD") {
+      this.sendResponse(
+        res,
+        405,
+        { Allow: "GET, HEAD", "Content-Type": "text/plain" },
+        isHead ? void 0 : Buffer.from("Method Not Allowed")
+      );
+      return;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    let decodedPathname = "/";
+    try {
+      decodedPathname = decodeURIComponent(url.pathname);
+    } catch {
+      this.sendResponse(
+        res,
+        400,
+        { "Content-Type": "text/plain" },
+        isHead ? void 0 : Buffer.from("Invalid path")
+      );
+      return;
+    }
+    const pathname = decodedPathname === "/" ? "/index.html" : decodedPathname;
+    const relativePath = this.sanitizePath(pathname);
+    if (!relativePath) {
+      this.sendResponse(
+        res,
+        400,
+        { "Content-Type": "text/plain" },
+        isHead ? void 0 : Buffer.from("Invalid path")
+      );
+      return;
+    }
+    const basePath = join(this.appConfig.absolutePaths.distDir, relativePath);
+    if (pathname.includes(".")) {
+      this.serveFile(req, res, basePath);
+      return;
+    }
+    const htmlCandidates = [`${basePath}.html`, join(basePath, "index.html")];
+    for (const candidate of htmlCandidates) {
+      if (fileSystem.exists(candidate)) {
+        this.serveFile(req, res, candidate);
+        return;
+      }
+    }
+    this.sendNotFoundPage(req, res);
+  }
+  async start() {
+    if (this.server) {
+      return this.server;
+    }
+    this.server = createServer(this.handleRequest.bind(this));
+    const hostname = this.options.hostname ?? DEFAULT_ECOPAGES_HOSTNAME;
+    const port = this.options.port ?? DEFAULT_ECOPAGES_PORT;
+    await new Promise((resolve) => {
+      this.server.listen(port, hostname, () => resolve());
+    });
+    return this.server;
+  }
+  async stop(force = true) {
+    if (!this.server) {
+      return;
+    }
+    const activeServer = this.server;
+    this.server = null;
+    await new Promise((resolve, reject) => {
+      activeServer.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+      if (force) {
+        activeServer.closeAllConnections();
+      }
+    });
+  }
+}
+export {
+  NodeStaticContentServer
+};

package/src/adapters/node/static-content-server.ts

@@ -0,0 +1,203 @@
+import { createServer, type IncomingMessage, type Server as NodeHttpServer, type ServerResponse } from 'node:http';
+import { extname, join, normalize, sep } from 'node:path';
+import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT, STATUS_MESSAGE } from '../../constants.ts';
+import { fileSystem } from '@ecopages/file-system';
+import type { EcoPagesAppConfig } from '../../internal-types.ts';
+import { ServerUtils } from '../../utils/server-utils.module.ts';
+
+type NodeStaticContentServerOptions = {
+	hostname?: string;
+	port?: number;
+};
+
+export class NodeStaticContentServer {
+	private readonly appConfig: EcoPagesAppConfig;
+	private readonly options: NodeStaticContentServerOptions;
+	private server: NodeHttpServer | null = null;
+
+	constructor({ appConfig, options }: { appConfig: EcoPagesAppConfig; options?: NodeStaticContentServerOptions }) {
+		this.appConfig = appConfig;
+		this.options = {
+			hostname: options?.hostname ?? DEFAULT_ECOPAGES_HOSTNAME,
+			port: options?.port ?? DEFAULT_ECOPAGES_PORT,
+		};
+	}
+
+	private shouldServeGzip(contentType: string): boolean {
+		return ['text/javascript', 'text/css'].includes(contentType);
+	}
+
+	private sanitizePath(pathname: string): string | null {
+		const withoutLeadingSlash = pathname.replace(/^\/+/, '');
+		const normalizedPath = normalize(withoutLeadingSlash);
+
+		if (normalizedPath.startsWith('..') || normalizedPath.includes(`..${sep}`)) {
+			return null;
+		}
+
+		return normalizedPath;
+	}
+
+	private sendResponse(res: ServerResponse, status: number, headers: Record<string, string>, body?: Buffer): void {
+		res.statusCode = status;
+		for (const [key, value] of Object.entries(headers)) {
+			res.setHeader(key, value);
+		}
+
+		if (!body) {
+			res.end();
+			return;
+		}
+
+		res.end(body);
+	}
+
+	private sendNotFoundPage(req: IncomingMessage, res: ServerResponse): void {
+		const error404TemplatePath = join(this.appConfig.absolutePaths.distDir, '404.html');
+		const isHead = (req.method ?? 'GET').toUpperCase() === 'HEAD';
+
+		if (!fileSystem.exists(error404TemplatePath)) {
+			this.sendResponse(
+				res,
+				404,
+				{ 'Content-Type': 'text/plain' },
+				isHead ? undefined : Buffer.from(STATUS_MESSAGE[404]),
+			);
+			return;
+		}
+
+		const file = fileSystem.readFileAsBuffer(error404TemplatePath);
+		this.sendResponse(res, 404, { 'Content-Type': 'text/html' }, isHead ? undefined : file);
+	}
+
+	private serveFile(req: IncomingMessage, res: ServerResponse, filePath: string, status = 200): void {
+		const contentType = ServerUtils.getContentType(extname(filePath));
+		const acceptsGzip = req.headers['accept-encoding']?.includes('gzip');
+		const isHead = (req.method ?? 'GET').toUpperCase() === 'HEAD';
+
+		if (acceptsGzip && this.shouldServeGzip(contentType)) {
+			const gzipPath = `${filePath}.gz`;
+			if (fileSystem.exists(gzipPath)) {
+				const file = fileSystem.readFileAsBuffer(gzipPath);
+				this.sendResponse(
+					res,
+					status,
+					{
+						'Content-Type': contentType,
+						'Content-Encoding': 'gzip',
+						Vary: 'Accept-Encoding',
+					},
+					isHead ? undefined : file,
+				);
+				return;
+			}
+		}
+
+		if (!fileSystem.exists(filePath)) {
+			this.sendNotFoundPage(req, res);
+			return;
+		}
+
+		const file = fileSystem.readFileAsBuffer(filePath);
+		this.sendResponse(res, status, { 'Content-Type': contentType }, isHead ? undefined : file);
+	}
+
+	private handleRequest(req: IncomingMessage, res: ServerResponse): void {
+		const method = (req.method ?? 'GET').toUpperCase();
+		const isHead = method === 'HEAD';
+		if (method !== 'GET' && method !== 'HEAD') {
+			this.sendResponse(
+				res,
+				405,
+				{ Allow: 'GET, HEAD', 'Content-Type': 'text/plain' },
+				isHead ? undefined : Buffer.from('Method Not Allowed'),
+			);
+			return;
+		}
+
+		const url = new URL(req.url ?? '/', 'http://localhost');
+		let decodedPathname = '/';
+		try {
+			decodedPathname = decodeURIComponent(url.pathname);
+		} catch {
+			this.sendResponse(
+				res,
+				400,
+				{ 'Content-Type': 'text/plain' },
+				isHead ? undefined : Buffer.from('Invalid path'),
+			);
+			return;
+		}
+
+		const pathname = decodedPathname === '/' ? '/index.html' : decodedPathname;
+		const relativePath = this.sanitizePath(pathname);
+
+		if (!relativePath) {
+			this.sendResponse(
+				res,
+				400,
+				{ 'Content-Type': 'text/plain' },
+				isHead ? undefined : Buffer.from('Invalid path'),
+			);
+			return;
+		}
+
+		const basePath = join(this.appConfig.absolutePaths.distDir, relativePath);
+
+		if (pathname.includes('.')) {
+			this.serveFile(req, res, basePath);
+			return;
+		}
+
+		const htmlCandidates = [`${basePath}.html`, join(basePath, 'index.html')];
+
+		for (const candidate of htmlCandidates) {
+			if (fileSystem.exists(candidate)) {
+				this.serveFile(req, res, candidate);
+				return;
+			}
+		}
+
+		this.sendNotFoundPage(req, res);
+	}
+
+	public async start(): Promise<NodeHttpServer> {
+		if (this.server) {
+			return this.server;
+		}
+
+		this.server = createServer(this.handleRequest.bind(this));
+		const hostname = this.options.hostname ?? DEFAULT_ECOPAGES_HOSTNAME;
+		const port = this.options.port ?? DEFAULT_ECOPAGES_PORT;
+
+		await new Promise<void>((resolve) => {
+			this.server!.listen(port, hostname, () => resolve());
+		});
+
+		return this.server;
+	}
+
+	public async stop(force = true): Promise<void> {
+		if (!this.server) {
+			return;
+		}
+
+		const activeServer = this.server;
+		this.server = null;
+
+		await new Promise<void>((resolve, reject) => {
+			activeServer.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+
+				resolve();
+			});
+
+			if (force) {
+				activeServer.closeAllConnections();
+			}
+		});
+	}
+}

package/src/adapters/shared/api-response.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A builder class for creating Response objects fluently.
+ */
+export declare class ApiResponseBuilder {
+    private _status;
+    private _headers;
+    /**
+     * Sets the HTTP status code for the response.
+     * @param code - The HTTP status code.
+     * @returns The builder instance for chaining.
+     */
+    status(code: Response['status']): this;
+    /**
+     * Adds or merges headers for the response.
+     * @param headersInit - Headers to add or merge.
+     * @returns The builder instance for chaining.
+     */
+    headers(headersInit: HeadersInit): this;
+    /**
+     * Creates a JSON response using the configured status and headers.
+     * @param data - The data to serialize.
+     * @returns A Response object.
+     */
+    json(data: any): Response;
+    /**
+     * Creates a plain text response using the configured status and headers.
+     * @param data - The text content.
+     * @returns A Response object.
+     */
+    text(data: string): Response;
+    /**
+     * Creates an HTML response using the configured status and headers.
+     * @param data - The HTML content.
+     * @returns A Response object.
+     */
+    html(data: string): Response;
+    /**
+     * Creates a redirect response.
+     * @param url - The URL to redirect to.
+     * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 302 if not set via status().
+     * @returns A Response object.
+     */
+    redirect(url: string, explicitStatus?: Response['status']): Response;
+    /**
+     * Creates an error response using the configured status and headers.
+     * If data is an object, it's treated as JSON, otherwise as text.
+     * @param data - The error data (string or object).
+     * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 500 if not set via status().
+     * @returns A Response object.
+     */
+    error(data: string | object, explicitStatus?: Response['status']): Response;
+}

package/src/adapters/shared/api-response.js

@@ -0,0 +1,96 @@
+class ApiResponseBuilder {
+  _status = 200;
+  _headers = new Headers();
+  /**
+   * Sets the HTTP status code for the response.
+   * @param code - The HTTP status code.
+   * @returns The builder instance for chaining.
+   */
+  status(code) {
+    this._status = code;
+    return this;
+  }
+  /**
+   * Adds or merges headers for the response.
+   * @param headersInit - Headers to add or merge.
+   * @returns The builder instance for chaining.
+   */
+  headers(headersInit) {
+    const inputHeaders = new Headers(headersInit);
+    inputHeaders.forEach((value, key) => {
+      this._headers.set(key, value);
+    });
+    return this;
+  }
+  /**
+   * Creates a JSON response using the configured status and headers.
+   * @param data - The data to serialize.
+   * @returns A Response object.
+   */
+  json(data) {
+    if (!this._headers.has("Content-Type")) {
+      this._headers.set("Content-Type", "application/json; charset=utf-8");
+    }
+    return new Response(JSON.stringify(data), { status: this._status, headers: this._headers });
+  }
+  /**
+   * Creates a plain text response using the configured status and headers.
+   * @param data - The text content.
+   * @returns A Response object.
+   */
+  text(data) {
+    if (!this._headers.has("Content-Type")) {
+      this._headers.set("Content-Type", "text/plain; charset=utf-8");
+    }
+    return new Response(data, { status: this._status, headers: this._headers });
+  }
+  /**
+   * Creates an HTML response using the configured status and headers.
+   * @param data - The HTML content.
+   * @returns A Response object.
+   */
+  html(data) {
+    if (!this._headers.has("Content-Type")) {
+      this._headers.set("Content-Type", "text/html; charset=utf-8");
+    }
+    return new Response(data, { status: this._status, headers: this._headers });
+  }
+  /**
+   * Creates a redirect response.
+   * @param url - The URL to redirect to.
+   * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 302 if not set via status().
+   * @returns A Response object.
+   */
+  redirect(url, explicitStatus) {
+    const redirectStatus = explicitStatus ?? (this._status === 200 ? 302 : this._status);
+    this._headers.set("Location", url);
+    return new Response(null, { status: redirectStatus, headers: this._headers });
+  }
+  /**
+   * Creates an error response using the configured status and headers.
+   * If data is an object, it's treated as JSON, otherwise as text.
+   * @param data - The error data (string or object).
+   * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 500 if not set via status().
+   * @returns A Response object.
+   */
+  error(data, explicitStatus) {
+    const errorStatus = explicitStatus ?? (this._status === 200 ? 500 : this._status);
+    this.status(errorStatus);
+    if (typeof data === "object" && data !== null) {
+      if (!this._headers.has("Content-Type")) {
+        this._headers.set("Content-Type", "application/json; charset=utf-8");
+      }
+      return new Response(JSON.stringify({ error: data }), {
+        status: this._status,
+        headers: this._headers
+      });
+    }
+    if (!this._headers.has("Content-Type")) {
+      this._headers.set("Content-Type", "text/plain; charset=utf-8");
+    }
+    return new Response(String(data), { status: this._status, headers: this._headers });
+  }
+}
+export {
+  ApiResponseBuilder
+};

package/src/adapters/shared/api-response.ts

@@ -0,0 +1,104 @@
+/**
+ * A builder class for creating Response objects fluently.
+ */
+export class ApiResponseBuilder {
+	private _status: Response['status'] = 200;
+	private _headers: Headers = new Headers();
+
+	/**
+	 * Sets the HTTP status code for the response.
+	 * @param code - The HTTP status code.
+	 * @returns The builder instance for chaining.
+	 */
+	status(code: Response['status']): this {
+		this._status = code;
+		return this;
+	}
+
+	/**
+	 * Adds or merges headers for the response.
+	 * @param headersInit - Headers to add or merge.
+	 * @returns The builder instance for chaining.
+	 */
+	headers(headersInit: HeadersInit): this {
+		const inputHeaders = new Headers(headersInit);
+		inputHeaders.forEach((value, key) => {
+			this._headers.set(key, value);
+		});
+		return this;
+	}
+
+	/**
+	 * Creates a JSON response using the configured status and headers.
+	 * @param data - The data to serialize.
+	 * @returns A Response object.
+	 */
+	json(data: any): Response {
+		if (!this._headers.has('Content-Type')) {
+			this._headers.set('Content-Type', 'application/json; charset=utf-8');
+		}
+		return new Response(JSON.stringify(data), { status: this._status, headers: this._headers });
+	}
+
+	/**
+	 * Creates a plain text response using the configured status and headers.
+	 * @param data - The text content.
+	 * @returns A Response object.
+	 */
+	text(data: string): Response {
+		if (!this._headers.has('Content-Type')) {
+			this._headers.set('Content-Type', 'text/plain; charset=utf-8');
+		}
+		return new Response(data, { status: this._status, headers: this._headers });
+	}
+
+	/**
+	 * Creates an HTML response using the configured status and headers.
+	 * @param data - The HTML content.
+	 * @returns A Response object.
+	 */
+	html(data: string): Response {
+		if (!this._headers.has('Content-Type')) {
+			this._headers.set('Content-Type', 'text/html; charset=utf-8');
+		}
+		return new Response(data, { status: this._status, headers: this._headers });
+	}
+
+	/**
+	 * Creates a redirect response.
+	 * @param url - The URL to redirect to.
+	 * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 302 if not set via status().
+	 * @returns A Response object.
+	 */
+	redirect(url: string, explicitStatus?: Response['status']): Response {
+		const redirectStatus = explicitStatus ?? (this._status === 200 ? 302 : this._status); // Default to 302 if status wasn't explicitly set
+		this._headers.set('Location', url);
+		return new Response(null, { status: redirectStatus, headers: this._headers });
+	}
+
+	/**
+	 * Creates an error response using the configured status and headers.
+	 * If data is an object, it's treated as JSON, otherwise as text.
+	 * @param data - The error data (string or object).
+	 * @param explicitStatus - Optional explicit status code (overrides status() if provided). Defaults to 500 if not set via status().
+	 * @returns A Response object.
+	 */
+	error(data: string | object, explicitStatus?: Response['status']): Response {
+		const errorStatus = explicitStatus ?? (this._status === 200 ? 500 : this._status); // Default to 500 if status wasn't explicitly set
+		this.status(errorStatus);
+
+		if (typeof data === 'object' && data !== null) {
+			if (!this._headers.has('Content-Type')) {
+				this._headers.set('Content-Type', 'application/json; charset=utf-8');
+			}
+			return new Response(JSON.stringify({ error: data }), {
+				status: this._status,
+				headers: this._headers,
+			});
+		}
+		if (!this._headers.has('Content-Type')) {
+			this._headers.set('Content-Type', 'text/plain; charset=utf-8');
+		}
+		return new Response(String(data), { status: this._status, headers: this._headers });
+	}
+}

package/src/adapters/shared/application-adapter.d.ts

@@ -0,0 +1,18 @@
+import type { ApiHandler, ApiHandlerContext, Middleware, RouteGroupBuilder, RouteOptions } from '../../public-types.js';
+import { AbstractApplicationAdapter, type ApplicationAdapterOptions, type RouteGroupDefinition, type RouteHandler } from '../abstract/application-adapter.js';
+export declare abstract class SharedApplicationAdapter<TOptions extends ApplicationAdapterOptions = ApplicationAdapterOptions, TServer = any, TRequest extends Request = Request> extends AbstractApplicationAdapter<TOptions, TServer, TRequest> {
+    protected register<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, method: ApiHandler['method'], handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    get<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    post<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    put<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    delete<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    patch<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    options<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    head<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(path: P, handler: RouteHandler<TRequest, TServer, TContext>, options?: RouteOptions<TRequest, TServer, TContext>): this;
+    route<P extends string>(path: P, method: ApiHandler['method'], handler: RouteHandler<TRequest, TServer>, options?: RouteOptions<TRequest, TServer>): this;
+    add(handler: ApiHandler<string, TRequest, TServer>): this;
+    group<TMiddleware extends readonly Middleware<TRequest, TServer, any>[] = []>(prefixOrGroup: string | RouteGroupDefinition<TRequest, TServer>, callback?: (builder: TMiddleware extends readonly Middleware<TRequest, TServer, infer TContext>[] ? RouteGroupBuilder<TRequest, TServer, TContext> : RouteGroupBuilder<TRequest, TServer>) => void, options?: {
+        middleware?: TMiddleware;
+    }): this;
+    private registerGroup;
+}