alepha 0.7.7 → 0.8.0

package/server/helmet.d.ts

@@ -0,0 +1,72 @@
+import { Alepha, HookDescriptor, Module } from "alepha";
+
+//#region src/providers/ServerHelmetProvider.d.ts
+type CspDirective = string | string[];
+interface CspOptions {
+  directives: {
+    "default-src"?: CspDirective;
+    "script-src"?: CspDirective;
+    "style-src"?: CspDirective;
+    "img-src"?: CspDirective;
+    "connect-src"?: CspDirective;
+    "font-src"?: CspDirective;
+    "object-src"?: CspDirective;
+    "media-src"?: CspDirective;
+    "frame-src"?: CspDirective;
+    sandbox?: CspDirective | boolean;
+    "report-uri"?: string;
+    "child-src"?: CspDirective;
+    "form-action"?: CspDirective;
+    "frame-ancestors"?: CspDirective;
+    "plugin-types"?: CspDirective;
+    "base-uri"?: CspDirective;
+    [key: string]: CspDirective | undefined | boolean;
+  };
+}
+interface HstsOptions {
+  maxAge?: number;
+  includeSubDomains?: boolean;
+  preload?: boolean;
+}
+interface HelmetOptions {
+  isSecure?: boolean;
+  strictTransportSecurity?: HstsOptions | false;
+  xContentTypeOptions?: false;
+  xFrameOptions?: "DENY" | "SAMEORIGIN" | false;
+  xXssProtection?: false;
+  contentSecurityPolicy?: CspOptions | false;
+  referrerPolicy?: "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | false;
+}
+/**
+* Provides a configurable way to apply essential HTTP security headers
+* to every server response, without external dependencies.
+*/
+declare class ServerHelmetProvider {
+  protected readonly alepha: Alepha;
+  /**
+  * The configuration options. These can be overridden during
+  * the application's configuration phase using `alepha.configure()`.
+  */
+  options: HelmetOptions;
+  private buildHeaders;
+  protected readonly onResponse: HookDescriptor<"server:onResponse">;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Helmet Module
+*
+* Automatically adds important HTTP security headers to every response
+* to help protect your application from common web vulnerabilities.
+*
+* @see {@link ServerHelmetProvider}
+* @module alepha.server.helmet
+*/
+declare class AlephaServerHelmet implements Module {
+  readonly name = "alepha.server.helmet";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerHelmet, CspOptions, HelmetOptions, HstsOptions, ServerHelmetProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/helmet.js

@@ -0,0 +1 @@
+export * from '@alepha/server-helmet'

package/server/links.d.ts

@@ -1,18 +1,13 @@
-import * as _alepha_core23 from "@alepha/core";
-import * as _alepha_core24 from "@alepha/core";
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, KIND, Module, OPTIONS } from "@alepha/core";
-import * as _alepha_server16 from "@alepha/server";
-import { ActionDescriptor, ActionDescriptorHelper, ApiLink, ApiLinksResponse, ClientRequestOptions, FetchResponse, HttpClient, RequestConfigSchema, ServerActionDescriptorProvider, ServerHandler, ServerRemote, ServerRequestConfigEntry } from "@alepha/server";
-import * as _alepha_retry27 from "@alepha/retry";
-import { ProxyDescriptorOptions, ProxyDescriptorProvider } from "@alepha/server-proxy";
-import { ServiceAccountDescriptor, UserAccountToken } from "@alepha/security";
-import * as _sinclair_typebox1 from "@sinclair/typebox";
+import { Alepha, HookDescriptor, KIND, Logger, Module, OPTIONS, TAny, TArray, TObject, TOptional, TRecord, TString } from "alepha";
+import { ActionDescriptor, ActionDescriptorHelper, ApiLink, ApiLinksResponse, ClientRequestOptions, FetchResponse, HttpClient, RequestConfigSchema, RouteDescriptor, ServerActionDescriptorProvider, ServerHandler, ServerRemote, ServerRequestConfigEntry } from "alepha/server";
+import { RetryDescriptor } from "alepha/retry";
+import { ProxyDescriptorOptions, ProxyDescriptorProvider } from "alepha/server/proxy";
+import { ServiceAccountDescriptor, UserAccountToken } from "alepha/security";
 
 //#region src/providers/LinkProvider.d.ts
 declare class LinkProvider {
   readonly URL_LINKS = "/api/_links";
-  protected readonly log: _alepha_core23.Logger;
+  protected readonly log: Logger;
   protected readonly alepha: Alepha;
   protected readonly httpClient: HttpClient;
   links?: Array<HttpClientLink>;
@@ -20,20 +15,24 @@ declare class LinkProvider {
   getLinks(force?: boolean): Promise<HttpClientLink[]>;
   client<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
   /**
-   * Resolve a link by its name and call it.
-   * - If link is local, it will call the local handler.
-   * - If link is remote, it will make a fetch request to the remote server.
-   */
+  * Resolve a link by its name and call it.
+  * - If link is local, it will call the local handler.
+  * - If link is remote, it will make a fetch request to the remote server.
+  */
   follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
   protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
   can(name: string): boolean;
   protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
 }
+// ---------------------------------------------------------------------------------------------------------------------
 interface HttpClientLink extends ApiLink {
   secured?: boolean;
   prefix?: string;
+  // -- server only --
+  // only for remote actions
   host?: string;
   service?: string;
+  // used only for local actions, not for remote actions
   schema?: RequestConfigSchema;
   handler?: ServerHandler;
 }
@@ -53,46 +52,46 @@ declare const $client: <T extends object>(scope?: ClientScope) => HttpVirtualCli
 declare const KEY = "REMOTE";
 interface RemoteDescriptorOptions {
   /**
-   * The URL of the remote service.
-   * You can use a function to generate the URL dynamically.
-   * You probably should use $inject(env) to get the URL from the environment.
-   *
-   * @example
-   * ```ts
-   * import { $remote } from "@alepha/server";
-   * import { $inject, t } from "@alepha/core";
-   *
-   * class App {
-   *   env = $inject(t.object({
-   *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
-   *   }));
-   *   remote = $remote({
-   *     url: this.env.REMOTE_URL,
-   *   });
-   * }
-   * ```
-   */
+  * The URL of the remote service.
+  * You can use a function to generate the URL dynamically.
+  * You probably should use $inject(env) to get the URL from the environment.
+  *
+  * @example
+  * ```ts
+  * import { $remote } from "alepha/server";
+  * import { $inject, t } from "alepha";
+  *
+  * class App {
+  *   env = $inject(t.object({
+  *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
+  *   }));
+  *   remote = $remote({
+  *     url: this.env.REMOTE_URL,
+  *   });
+  * }
+  * ```
+  */
   url: string | (() => string);
   /**
-   * The name of the remote service.
-   *
-   * @default Member of the class containing the remote service.
-   */
+  * The name of the remote service.
+  *
+  * @default Member of the class containing the remote service.
+  */
   name?: string;
   /**
-   * If true, all methods of the remote service will be exposed as actions in this context.
-   * > Note: Proxy will never use the service account, it just... proxies the request.
-   */
+  * If true, all methods of the remote service will be exposed as actions in this context.
+  * > Note: Proxy will never use the service account, it just... proxies the request.
+  */
   proxy?: boolean | Partial<ProxyDescriptorOptions & {
     /**
-     * If true, the remote service won't be available internally, only through the proxy.
-     */
+    * If true, the remote service won't be available internally, only through the proxy.
+    */
     noInternal: boolean;
   }>;
   /**
-   * For communication between the server and the remote service with a security layer.
-   * This will be used for internal communication and will not be exposed to the client.
-   */
+  * For communication between the server and the remote service with a security layer.
+  * This will be used for internal communication and will not be exposed to the client.
+  */
   serviceAccount?: ServiceAccountDescriptor;
 }
 interface RemoteDescriptor {
@@ -100,14 +99,14 @@ interface RemoteDescriptor {
   [OPTIONS]: RemoteDescriptorOptions;
 }
 /**
- * $remote is a descriptor that allows you to define a remote service access.
- *
- * Use it only when you have 2 or more services that need to communicate with each other.
- *
- * All remote services can be exposed as actions, ... or not.
- *
- * You can add a service account if you want to use a security layer.
- */
+* $remote is a descriptor that allows you to define a remote service access.
+*
+* Use it only when you have 2 or more services that need to communicate with each other.
+*
+* All remote services can be exposed as actions, ... or not.
+*
+* You can add a service account if you want to use a security layer.
+*/
 declare const $remote: {
   (options: RemoteDescriptorOptions): RemoteDescriptor;
   [KIND]: string;
@@ -122,26 +121,17 @@ declare class RemoteDescriptorProvider {
   protected readonly client: LinkProvider;
   protected readonly proxyProvider: ProxyDescriptorProvider;
   protected readonly remotes: Array<ServerRemote>;
-  protected readonly log: _alepha_core24.Logger;
+  protected readonly log: Logger;
   getRemotes(): ServerRemote[];
-  readonly configure: _alepha_core24.HookDescriptor<"configure">;
-  readonly start: _alepha_core24.HookDescriptor<"start">;
+  readonly configure: HookDescriptor<"configure">;
+  readonly start: HookDescriptor<"start">;
   registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
-  protected readonly fetchLinks: _alepha_retry27.RetryDescriptor<(opts: {
-    service: string;
-    url: string;
-    authorization?: string;
-  }) => Promise<{
-    prefix?: string | undefined;
-    links: {
-      method?: string | undefined;
-      group?: string | undefined;
-      requestBodyType?: string | undefined;
-      service?: string | undefined;
-      name: string;
-      path: string;
-    }[];
-  }>>;
+  protected readonly fetchLinks: RetryDescriptor<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
+}
+interface FetchLinksOptions {
+  service: string;
+  url: string;
+  authorization?: string;
 }
 //#endregion
 //#region src/providers/ServerLinksProvider.d.ts
@@ -151,25 +141,25 @@ declare class ServerLinksProvider {
   protected readonly helper: ActionDescriptorHelper;
   protected readonly remoteProvider: RemoteDescriptorProvider;
   protected readonly serverActionDescriptorProvider: ServerActionDescriptorProvider;
-  readonly onRoute: _alepha_core0.HookDescriptor<"server:onRoute">;
-  readonly links: _alepha_server16.RouteDescriptor<{
-    response: _sinclair_typebox1.TObject<{
-      prefix: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
-      links: _sinclair_typebox1.TArray<_sinclair_typebox1.TObject<{
-        name: _sinclair_typebox1.TString;
-        path: _sinclair_typebox1.TString;
-        method: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
-        group: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
-        requestBodyType: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
-        service: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
+  readonly onRoute: HookDescriptor<"server:onRoute">;
+  readonly links: RouteDescriptor<{
+    response: TObject<{
+      prefix: TOptional<TString>;
+      links: TArray<TObject<{
+        name: TString;
+        path: TString;
+        method: TOptional<TString>;
+        group: TOptional<TString>;
+        requestBodyType: TOptional<TString>;
+        service: TOptional<TString>;
       }>>;
     }>;
   }>;
-  readonly schema: _alepha_server16.RouteDescriptor<{
-    params: _sinclair_typebox1.TObject<{
-      name: _sinclair_typebox1.TString;
+  readonly schema: RouteDescriptor<{
+    params: TObject<{
+      name: TString;
     }>;
-    response: _sinclair_typebox1.TRecord<_sinclair_typebox1.TString, _sinclair_typebox1.TAny>;
+    response: TRecord<TString, TAny>;
   }>;
   getLinks(options: GetLinksOptions): Promise<ApiLinksResponse>;
 }
@@ -179,10 +169,11 @@ interface GetLinksOptions {
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 declare class AlephaServerLinks implements Module {
   readonly name = "alepha.server.links";
   readonly $services: (alepha: Alepha) => void;
 }
 //#endregion
-export { $client, $remote, AlephaServerLinks, ClientScope, GetLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider };
+export { $client, $remote, AlephaServerLinks, ClientScope, FetchLinksOptions, GetLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/metrics.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-metrics');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/server/metrics.d.ts

@@ -0,0 +1,37 @@
+import { RouteDescriptor } from "alepha/server";
+import { Alepha, HookDescriptor, Module } from "alepha";
+import { Registry } from "prom-client";
+
+//#region src/providers/ServerMetricsProvider.d.ts
+interface ServerMetricsProviderOptions {
+  prefix?: string;
+  gcDurationBuckets?: number[];
+  eventLoopMonitoringPrecision?: number;
+  labels?: object;
+}
+declare class ServerMetricsProvider {
+  protected readonly register: Registry;
+  protected readonly alepha: Alepha;
+  readonly options: ServerMetricsProviderOptions;
+  readonly metrics: RouteDescriptor;
+  protected readonly onStart: HookDescriptor<"start">;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Metrics Module
+*
+* This module provides prometheus metrics for the Alepha server.
+* Metrics are exposed at the `/metrics` endpoint.
+*
+* @see {@link ServerMetricsProvider}
+* @module alepha.server.metrics
+*/
+declare class AlephaServerMetrics implements Module {
+  readonly name = "alepha.server.metrics";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerMetrics, ServerMetricsProvider, ServerMetricsProviderOptions };
+//# sourceMappingURL=index.d.ts.map

package/server/metrics.js

@@ -0,0 +1 @@
+export * from '@alepha/server-metrics'

package/server/multipart.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-multipart');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/server/multipart.d.ts

@@ -0,0 +1,48 @@
+import { ActionDescriptorHelper, ServerRoute } from "alepha/server";
+import { Alepha, FileLike, HookDescriptor, Module } from "alepha";
+import { BusboyConfig } from "@fastify/busboy";
+import { IncomingMessage } from "node:http";
+
+//#region src/providers/ServerMultipartProvider.d.ts
+declare class ServerMultipartProvider {
+  protected readonly helper: ActionDescriptorHelper;
+  protected readonly alepha: Alepha;
+  readonly onRequest: HookDescriptor<"server:onRequest">;
+  readonly onSend: HookDescriptor<"server:onResponse">;
+  handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
+    body: Record<string, any>;
+    cleanup: () => Promise<void>;
+  }>;
+  parseMultipart(req: IncomingMessage, config?: Omit<BusboyConfig, "headers">): Promise<MultipartResult>;
+}
+interface MultipartResult {
+  fields: Record<string, string | string[]>;
+  files: Record<string, HybridFile>;
+}
+interface HybridFile extends FileLike {
+  cleanup(): Promise<void>;
+  _state: {
+    cleanup: boolean;
+    size: number;
+    tmpPath: string;
+  };
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Multipart Module
+*
+* This module provides support for handling multipart/form-data requests.
+* It allows to parse body data containing t.file().
+*
+* @see {@link ServerMultipartProvider}
+* @module alepha.server.multipart
+*/
+declare class AlephaServerMultipart implements Module {
+  readonly name = "alepha.server.multipart";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerMultipart, ServerMultipartProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/multipart.js

@@ -0,0 +1 @@
+export * from '@alepha/server-multipart'

package/server/proxy.d.ts

@@ -1,11 +1,10 @@
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, Async, KIND, Module, OPTIONS } from "@alepha/core";
-import { ServerHandler, ServerRequest, ServerRouterProvider } from "@alepha/server";
+import { Alepha, Async, HookDescriptor, KIND, Logger, Module, OPTIONS } from "alepha";
+import { ServerHandler, ServerRequest, ServerRouterProvider } from "alepha/server";
 
 //#region src/descriptors/$proxy.d.ts
 type ProxyDescriptorOptions = {
   path: string;
-  target: string;
+  target: string | (() => string);
   disabled?: boolean;
   beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
   afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
@@ -22,16 +21,17 @@ declare const $proxy: {
 //#endregion
 //#region src/providers/ProxyDescriptorProvider.d.ts
 declare class ProxyDescriptorProvider {
-  protected readonly log: _alepha_core0.Logger;
+  protected readonly log: Logger;
   protected readonly routerProvider: ServerRouterProvider;
   protected readonly alepha: Alepha;
-  readonly configure: _alepha_core0.HookDescriptor<"configure">;
-  createProxyHandler(options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
+  readonly configure: HookDescriptor<"configure">;
+  createProxyHandler(target: string, options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
   proxy(options: ProxyDescriptorOptions): Promise<void>;
   private getRawRequestBody;
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 declare class AlephaServerProxy implements Module {
   readonly name = "alepha.server.proxy";
   readonly $services: (alepha: Alepha) => void;

package/server/static.d.ts

@@ -1,78 +1,77 @@
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, KIND, OPTIONS } from "@alepha/core";
-import { DateTimeProvider, DurationLike } from "@alepha/datetime";
-import { ServerHandler, ServerRouterProvider } from "@alepha/server";
+import { Alepha, HookDescriptor, KIND, Logger, OPTIONS } from "alepha";
+import { ServerHandler, ServerRouterProvider } from "alepha/server";
+import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$serve.d.ts
 declare const KEY = "SERVE";
 interface ServeDescriptorOptions {
   /**
-   * Prefix for the served path.
-   *
-   * @default "/"
-   */
+  * Prefix for the served path.
+  *
+  * @default "/"
+  */
   path?: string;
   /**
-   * Path to the directory to serve.
-   *
-   * @default process.cwd()
-   */
+  * Path to the directory to serve.
+  *
+  * @default process.cwd()
+  */
   root?: string;
   /**
-   * If true, descriptor will be ignored.
-   *
-   * @default false
-   */
+  * If true, descriptor will be ignored.
+  *
+  * @default false
+  */
   disabled?: boolean;
   /**
-   * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
-   *
-   * @default true
-   */
+  * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
+  *
+  * @default true
+  */
   ignoreDotEnvFiles?: boolean;
   /**
-   * Whether to use the index.html file when the path is a directory.
-   *
-   * @default true
-   */
+  * Whether to use the index.html file when the path is a directory.
+  *
+  * @default true
+  */
   indexFallback?: boolean;
   /**
-   * Force all requests "not found" to be served with the index.html file.
-   * This is useful for single-page applications (SPAs) that use client-side only routing.
-   */
+  * Force all requests "not found" to be served with the index.html file.
+  * This is useful for single-page applications (SPAs) that use client-side only routing.
+  */
   historyApiFallback?: boolean;
   /**
-   * Optional name of the descriptor.
-   * This is used for logging and debugging purposes.
-   *
-   * @default Key name.
-   */
+  * Optional name of the descriptor.
+  * This is used for logging and debugging purposes.
+  *
+  * @default Key name.
+  */
   name?: string;
   /**
-   * Whether to use cache control headers.
-   *
-   * @default {}
-   */
+  * Whether to use cache control headers.
+  *
+  * @default {}
+  */
   cacheControl?: Partial<CacheControlOptions> | false;
 }
 interface CacheControlOptions {
   /**
-   * Whether to use cache control headers.
-   *
-   * @default [.js, .css]
-   */
+  * Whether to use cache control headers.
+  *
+  * @default [.js, .css]
+  */
   fileTypes: string[];
   /**
-   * The maximum age of the cache in seconds.
-   *
-   * @default 60 * 60 * 24 * 2 // 2 days
-   */
+  * The maximum age of the cache in seconds.
+  *
+  * @default 60 * 60 * 24 * 2 // 2 days
+  */
   maxAge: DurationLike;
   /**
-   * Whether to use immutable cache control headers.
-   *
-   * @default true
-   */
+  * Whether to use immutable cache control headers.
+  *
+  * @default true
+  */
   immutable: boolean;
 }
 interface ServeDescriptor {
@@ -90,9 +89,9 @@ declare class ServerStaticProvider {
   protected readonly alepha: Alepha;
   protected readonly routerProvider: ServerRouterProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: _alepha_core0.Logger;
+  protected readonly log: Logger;
   protected readonly directories: ServeDirectory[];
-  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
+  protected readonly configure: HookDescriptor<"configure">;
   list(name: string): string[];
   serve(options: ServeDescriptorOptions): Promise<void>;
   createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
@@ -108,5 +107,18 @@ interface ServeDirectory {
   files: string[];
 }
 //#endregion
-export { $serve, CacheControlOptions, ServeDescriptor, ServeDescriptorOptions, ServeDirectory, ServerStaticProvider };
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Static Module
+*
+* @see {@link ServerStaticProvider}
+* @module alepha.server.static
+*/
+declare class AlephaServerStatic {
+  readonly name = "alepha.server.static";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { $serve, AlephaServerStatic, CacheControlOptions, ServeDescriptor, ServeDescriptorOptions, ServeDirectory, ServerStaticProvider };
 //# sourceMappingURL=index.d.ts.map